diff --git a/Guardfile b/Guardfile index 0d4ca4b62..e1fd16320 100644 --- a/Guardfile +++ b/Guardfile @@ -3,7 +3,8 @@ group :red_green_refactor, halt_on_fail: true do # be sure you have apache2 configured to # accept EPP request on port 701, what proxy to 8989. # port and environment is just for correct notification, all is overwritten by CLI - guard :rails, port: 8989, environment: 'test', CLI: 'RAILS_ENV=test unicorn -p 8989' do + guard :rails, port: 8989, environment: 'test' do + # guard :rails, port: 8989, environment: 'test', CLI: 'RAILS_ENV=test unicorn -p 8989' do watch('Gemfile.lock') watch(%r{^(config|lib)/.*}) end diff --git a/app/controllers/epp/contacts_controller.rb b/app/controllers/epp/contacts_controller.rb index 152561886..28a3f8102 100644 --- a/app/controllers/epp/contacts_controller.rb +++ b/app/controllers/epp/contacts_controller.rb @@ -16,6 +16,7 @@ class Epp::ContactsController < EppController def update # FIXME: Update returns 2303 update multiple times code = params_hash['epp']['command']['update']['update'][:id] + @contact = Contact.where(code: code).first # if update_rights? && stamp(@contact) && @contact.update_attributes(contact_and_address_attributes(:update)) if owner? && stamp(@contact) && @contact.update_attributes(contact_and_address_attributes(:update)) diff --git a/app/controllers/epp/domains_controller.rb b/app/controllers/epp/domains_controller.rb index 84ad12d85..82eae2105 100644 --- a/app/controllers/epp/domains_controller.rb +++ b/app/controllers/epp/domains_controller.rb @@ -126,13 +126,12 @@ class Epp::DomainsController < EppController end def validate_create - if params[:parsed_frame].css('dsData').count > 0 && params[:parsed_frame].css('create > keyData').count > 0 - epp_errors << { code: '2306', msg: I18n.t('ds_data_and_key_data_must_not_exists_together') } - end - @prefix = 'create > create >' requires('name', 'ns', 'registrant', 'ns > hostAttr') + @prefix = 'extension > create >' + mutually_exclusive 'keyData', 'dsData' + @prefix = nil requires('extension > extdata > legalDocument') end @@ -143,7 +142,7 @@ class Epp::DomainsController < EppController end def validate_update - if params[:parsed_frame].css('chg registrant').present? && params[:parsed_frame].css('legalDocument').blank? + if element_count('update > chg > registrant') > 0 requires('extension > extdata > legalDocument') end diff --git a/app/controllers/epp_controller.rb b/app/controllers/epp_controller.rb index bae8a357a..8981dcd8f 100644 --- a/app/controllers/epp_controller.rb +++ b/app/controllers/epp_controller.rb @@ -77,21 +77,22 @@ class EppController < ApplicationController # let's follow grape's validations: https://github.com/intridea/grape/#parameter-validation-and-coercion def exactly_one_of(*selectors) - present_count = 0 - selectors.each do |selector| - full_selector = [@prefix, selector].join(' ') - el = params[:parsed_frame].css(full_selector).first - present_count += 1 if el && el.text.present? - end - - return if present_count == 1 + return if element_count(*selectors) == 1 epp_errors << { - code: '2003', + code: '2306', msg: I18n.t(:exactly_one_parameter_required, params: selectors.join(' or ')) } end + def mutually_exclusive(*selectors) + return if element_count(*selectors) <= 1 + epp_errors << { + code: '2306', + msg: I18n.t(:mutally_exclusive_params, params: selectors.join(', ')) + } + end + def optional(selector, *validations) full_selector = [@prefix, selector].join(' ') el = params[:parsed_frame].css(full_selector).first @@ -105,6 +106,16 @@ class EppController < ApplicationController end end + def element_count(*selectors) + present_count = 0 + selectors.each do |selector| + full_selector = [@prefix, selector].join(' ') + el = params[:parsed_frame].css(full_selector).first + present_count += 1 if el && el.text.present? + end + present_count + end + def xml_attrs_present?(ph, attributes) # TODO: THIS IS DEPRECATED AND WILL BE REMOVED IN FUTURE attributes.each do |x| epp_errors << { @@ -124,6 +135,7 @@ class EppController < ApplicationController # rubocop: enable Style/PredicateName def write_to_epp_log + # return nil if EPP_LOG_ENABLED request_command = params[:command] || params[:action] # error receives :command, other methods receive :action ApiLog::EppLog.create({ request: params[:raw_frame] || params[:frame], diff --git a/app/views/epp/contacts/info.xml.builder b/app/views/epp/contacts/info.xml.builder index e12615c79..e354be0b2 100644 --- a/app/views/epp/contacts/info.xml.builder +++ b/app/views/epp/contacts/info.xml.builder @@ -11,7 +11,8 @@ xml.epp_head do xml.tag!('contact:voice', @contact.phone) if @disclosure.try(:phone) || @owner xml.tag!('contact:fax', @contact.fax) if @disclosure.try(:fax) || @owner xml.tag!('contact:email', @contact.email) if @disclosure.try(:email) || @owner - #xml.tag!('contact:clID', @current_epp_user.username) if @current_epp_user + xml.tag!('contact:clID', @contact.registrar.try(:name)) + #xml.tag!('contact:crID', @contact.cr_id ) if @contact.cr_id xml.tag!('contact:crDate', @contact.created_at) xml.tag!('contact:upID', @contact.up_id) if @contact.up_id diff --git a/config/environments/test.rb b/config/environments/test.rb index ecc572090..d7db4fa70 100644 --- a/config/environments/test.rb +++ b/config/environments/test.rb @@ -40,6 +40,10 @@ Rails.application.configure do # Raises error for missing translations # config.action_view.raise_on_missing_translations = true + # The available log levels are: :debug, :info, :warn, :error, :fatal, and :unknown, + # corresponding to the log level numbers from 0 up to 5 respectively + config.log_level = :fatal + # for finding database optimization config.after_initialize do Bullet.enable = true diff --git a/config/initializers/initial_settings.rb b/config/initializers/initial_settings.rb index 39517c12a..97743775f 100644 --- a/config/initializers/initial_settings.rb +++ b/config/initializers/initial_settings.rb @@ -24,3 +24,6 @@ if ActiveRecord::Base.connection.table_exists? 'settings' # otherwise rake not w Setting.save_default(:transfer_wait_time, 0) end + +# dev only setting +EPP_LOG_ENABLED = true # !Rails.env.test? diff --git a/config/locales/en.yml b/config/locales/en.yml index 677c8de96..b14579991 100644 --- a/config/locales/en.yml +++ b/config/locales/en.yml @@ -433,7 +433,6 @@ en: failed_to_delete_record: 'Failed to delete record' authentication_error: 'Authentication error' - ds_data_and_key_data_must_not_exists_together: 'dsData and keyData objects must not exists together' setting: 'Setting' @@ -501,3 +500,4 @@ en: could_not_determine_object_type_check_xml_format_and_namespaces: 'Could not determine object type. Check XML format and namespaces.' unknown_expiry_relative_pattern: 'Expiry relative must be compatible to ISO 8601' unknown_expiry_absolute_pattern: 'Expiry absolute must be compatible to ISO 8601' + mutally_exclusive_params: 'Mutually exclusive parameters: %{params}' diff --git a/spec/epp/contact_spec.rb b/spec/epp/contact_spec.rb index a190f4e41..dd094e126 100644 --- a/spec/epp/contact_spec.rb +++ b/spec/epp/contact_spec.rb @@ -1,132 +1,107 @@ require 'rails_helper' describe 'EPP Contact', epp: true do - before do + before :all do + Fabricate(:epp_user) + Fabricate(:epp_user, username: 'registrar1', registrar: registrar1) + Fabricate(:epp_user, username: 'registrar2', registrar: registrar2) + + login_as :gitlab + Contact.skip_callback(:create, :before, :generate_code) Contact.skip_callback(:create, :before, :generate_auth_info) + create_settings + create_disclosure_settings end - after do + after :all do Contact.set_callback(:create, :before, :generate_code) Contact.set_callback(:create, :before, :generate_auth_info) end - let(:server_zone) { Epp::Server.new({ server: 'localhost', tag: 'zone', password: 'ghyt9e4fu', port: 701 }) } - let(:server_elkdata) { Epp::Server.new({ server: 'localhost', tag: 'elkdata', password: 'ghyt9e4fu', port: 701 }) } - let(:elkdata) { Fabricate(:registrar, { name: 'Elkdata', reg_no: '123' }) } - let(:zone) { Registrar.where(reg_no: '12345678').first || Fabricate(:registrar) } - let(:epp_xml) { EppXml::Contact.new(cl_trid: 'ABC-12345') } - context 'with valid user' do - before do - Fabricate(:epp_user) - Fabricate(:epp_user, username: 'zone', registrar: zone) - Fabricate(:epp_user, username: 'elkdata', registrar: elkdata) - create_settings - create_disclosure_settings - end - context 'create command' do it 'fails if request xml is missing' do xml = epp_xml.create - response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2001') + response = epp_plain_request(xml, :xml) + response[:results][0][:msg].should == 'Command syntax error' + response[:results][0][:result_code].should == '2001' - expect(response[:results][0][:msg]).to eq('Command syntax error') - expect(response[:results].count).to eq 1 + response[:results].count.should == 1 end it 'fails if request xml is missing' do xml = epp_xml.create( postalInfo: { addr: { value: nil } } ) - response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2003') - expect(response[:results][1][:result_code]).to eq('2003') - expect(response[:results][2][:result_code]).to eq('2003') - expect(response[:results][3][:result_code]).to eq('2003') - expect(response[:results][4][:result_code]).to eq('2003') - expect(response[:results][5][:result_code]).to eq('2003') + response = epp_plain_request(xml, :xml) + response[:results][0][:msg].should == 'Required parameter missing: name' + response[:results][1][:msg].should == 'Required parameter missing: city' + response[:results][2][:msg].should == 'Required parameter missing: cc' + response[:results][3][:msg].should == 'Required parameter missing: ident' + response[:results][4][:msg].should == 'Required parameter missing: voice' + response[:results][5][:msg].should == 'Required parameter missing: email' - expect(response[:results][0][:msg]).to eq('Required parameter missing: name') - expect(response[:results][1][:msg]).to eq('Required parameter missing: city') - expect(response[:results][2][:msg]).to eq('Required parameter missing: cc') - expect(response[:results][3][:msg]).to eq('Required parameter missing: ident') - expect(response[:results][4][:msg]).to eq('Required parameter missing: voice') - expect(response[:results][5][:msg]).to eq('Required parameter missing: email') - expect(response[:results].count).to eq 6 + response[:results][0][:result_code].should == '2003' + response[:results][1][:result_code].should == '2003' + response[:results][2][:result_code].should == '2003' + response[:results][3][:result_code].should == '2003' + response[:results][4][:result_code].should == '2003' + response[:results][5][:result_code].should == '2003' + + response[:results].count.should == 6 end it 'successfully saves ident type' do xml = { ident: { value: '1990-22-12', attrs: { type: 'birthday' } } } - epp_request(create_contact_xml(xml), :xml) - expect(Contact.last.ident_type).to eq('birthday') + epp_plain_request(create_contact_xml(xml), :xml) + + Contact.last.ident_type.should == 'birthday' end it 'successfully creates a contact' do - response = epp_request(create_contact_xml, :xml) + response = epp_plain_request(create_contact_xml, :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') + response[:msg].should == 'Command completed successfully' + response[:result_code].should == '1000' - expect(Contact.first.registrar).to eq(zone) - expect(zone.epp_users).to include(Contact.first.created_by) - expect(Contact.first.updated_by_id).to eq nil + @contact = Contact.last - expect(Contact.count).to eq(1) + @contact.registrar.should == registrar1 + registrar1.epp_users.should include(@contact.created_by) + @contact.updated_by_id.should == nil + @contact.ident.should == '37605030299' + @contact.address.street.should == '123 Example' - expect(Contact.first.ident).to eq '37605030299' - - expect(Contact.first.address.street).to eq('123 Example') - - log = ApiLog::EppLog.all - - expect(log.length).to eq(4) - expect(log[0].request_command).to eq('hello') - expect(log[0].request_successful).to eq(true) - - expect(log[1].request_command).to eq('login') - expect(log[1].request_successful).to eq(true) - expect(log[1].api_user_name).to eq('zone') - expect(log[1].api_user_registrar).to eq('Registrar OÜ') - - expect(log[2].request_command).to eq('create') - expect(log[2].request_object).to eq('contact') - expect(log[2].request_successful).to eq(true) - expect(log[2].api_user_name).to eq('zone') - expect(log[2].api_user_registrar).to eq('Registrar OÜ') - expect(log[2].request).not_to be_blank - expect(log[2].response).not_to be_blank - - expect(log[3].request_command).to eq('logout') - expect(log[3].request_successful).to eq(true) - expect(log[3].api_user_name).to eq('zone') - expect(log[3].api_user_registrar).to eq('Registrar OÜ') + log = ApiLog::EppLog.last + log.request_command.should == 'create' + log.request_object.should == 'contact' + log.request_successful.should == true + log.api_user_name.should == 'gitlab' + log.api_user_registrar.should == 'Registrar OÜ' end it 'successfully adds registrar' do - response = epp_request(create_contact_xml, :xml) + response = epp_plain_request(create_contact_xml, :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') + response[:msg].should == 'Command completed successfully' + response[:result_code].should == '1000' - expect(Contact.count).to eq(1) - - expect(Contact.first.registrar).to eq(zone) + Contact.last.registrar.should == registrar1 end it 'returns result data upon success' do - response = epp_request(create_contact_xml, :xml) + response = epp_plain_request(create_contact_xml, :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') + response[:msg].should == 'Command completed successfully' + response[:result_code].should == '1000' id = response[:parsed].css('resData creData id').first cr_date = response[:parsed].css('resData creData crDate').first - expect(id.text.length).to eq(8) + id.text.length.should == 8 # 5 seconds for what-ever weird lag reasons might happen - expect(cr_date.text.to_time).to be_within(5).of(Time.now) + cr_date.text.to_time.should be_within(5).of(Time.now) end it 'creates disclosure data' do @@ -142,15 +117,16 @@ describe 'EPP Contact', epp: true do } } - response = epp_request(create_contact_xml(xml), :xml) - expect(response[:result_code]).to eq('1000') + response = epp_plain_request(create_contact_xml(xml), :xml) + response[:result_code].should == '1000' - expect(Contact.last.disclosure.name).to eq(true) - expect(Contact.last.disclosure.org_name).to eq(true) - expect(Contact.last.disclosure.phone).to eq(true) - expect(Contact.last.disclosure.fax).to eq(true) - expect(Contact.last.disclosure.email).to eq(true) - expect(Contact.last.disclosure.address).to eq(true) + @contact = Contact.last + @contact.disclosure.name.should == true + @contact.disclosure.org_name.should == true + @contact.disclosure.phone.should == true + @contact.disclosure.fax.should == true + @contact.disclosure.email.should == true + @contact.disclosure.address.should == true end it 'creates disclosure data merging with defaults' do @@ -162,65 +138,61 @@ describe 'EPP Contact', epp: true do } } - response = epp_request(create_contact_xml(xml), :xml) - expect(response[:result_code]).to eq('1000') + response = epp_plain_request(create_contact_xml(xml), :xml) + response[:result_code].should == '1000' - expect(Contact.last.disclosure.name).to eq(nil) - expect(Contact.last.disclosure.org_name).to eq(nil) - expect(Contact.last.disclosure.phone).to eq(true) - expect(Contact.last.disclosure.fax).to eq(nil) - expect(Contact.last.disclosure.email).to eq(nil) - expect(Contact.last.disclosure.address).to eq(true) + @contact = Contact.last + @contact.disclosure.name.should == nil + @contact.disclosure.org_name.should == nil + @contact.disclosure.phone.should == true + @contact.disclosure.fax.should == nil + @contact.disclosure.email.should == nil + @contact.disclosure.address.should == true end end context 'update command' do + before :all do + @contact = + Fabricate( + :contact, + created_by_id: 1, + registrar: registrar1, + email: 'not_updated@test.test', + code: 'sh8013', + auth_info: 'password' + ) + end + it 'fails if request is invalid' do xml = epp_xml.update - response = epp_request(xml, :xml) # epp_request('contacts/update_missing_attr.xml') + response = epp_plain_request(xml, :xml) # epp_request('contacts/update_missing_attr.xml') - expect(response[:results][0][:result_code]).to eq('2003') - expect(response[:results][0][:msg]).to eq('Required parameter missing: add, rem or chg') - expect(response[:results][1][:result_code]).to eq('2003') - expect(response[:results][1][:msg]).to eq('Required parameter missing: id') - expect(response[:results].count).to eq 2 + response[:results][0][:result_code].should == '2003' + response[:results][0][:msg].should == 'Required parameter missing: add, rem or chg' + response[:results][1][:result_code].should == '2003' + response[:results][1][:msg].should == 'Required parameter missing: id' + response[:results].count.should == 2 end it 'fails with wrong authentication info' do - Fabricate(:contact, code: 'sh8013', auth_info: 'password_wrong') - - response = epp_request(update_contact_xml({ id: { value: 'sh8013' } }), :xml, :elkdata) - - expect(response[:msg]).to eq('Authorization error') - expect(response[:result_code]).to eq('2201') + login_as :registrar2 do + response = epp_plain_request(update_contact_xml({ id: { value: 'sh8013' } }), :xml) + expect(response[:msg]).to eq('Authorization error') + expect(response[:result_code]).to eq('2201') + end end it 'is succesful' do - Fabricate( - :contact, - created_by_id: 1, - registrar: zone, - email: 'not_updated@test.test', - code: 'sh8013', - auth_info: 'password' - ) - response = epp_request(update_contact_xml({ id: { value: 'sh8013' } }), :xml) + response = epp_plain_request(update_contact_xml({ id: { value: 'sh8013' } }), :xml) - expect(response[:msg]).to eq('Command completed successfully') - expect(Contact.first.name).to eq('John Doe Edited') - expect(Contact.first.email).to eq('edited@example.example') + response[:msg].should == 'Command completed successfully' + @contact.reload + @contact.name.should == 'John Doe Edited' + @contact.email.should == 'edited@example.example' end it 'returns phone and email error' do - Fabricate( - :contact, - registrar: zone, - created_by_id: 1, - email: 'not_updated@test.test', - code: 'sh8013', - auth_info: 'password' - ) - xml = { id: { value: 'sh8013' }, chg: { @@ -229,233 +201,259 @@ describe 'EPP Contact', epp: true do } } - response = epp_request(update_contact_xml(xml), :xml) + response = epp_plain_request(update_contact_xml(xml), :xml) - expect(response[:results][0][:result_code]).to eq('2005') - expect(response[:results][0][:msg]).to eq('Phone nr is invalid') + response[:results][0][:msg].should == 'Phone nr is invalid' + response[:results][0][:result_code].should == '2005' - expect(response[:results][1][:result_code]).to eq('2005') - expect(response[:results][1][:msg]).to eq('Email is invalid') + response[:results][1][:msg].should == 'Email is invalid' + response[:results][1][:result_code].should == '2005' end it 'updates disclosure items' do - Fabricate(:contact, code: 'sh8013', auth_info: '2fooBAR', registrar: zone, created_by_id: EppUser.first.id, - disclosure: Fabricate(:contact_disclosure, phone: true, email: true)) + Fabricate( + :contact, + code: 'sh8013disclosure', + auth_info: '2fooBAR', + registrar: registrar1, + created_by_id: EppUser.first.id, + disclosure: Fabricate(:contact_disclosure, phone: true, email: true)) xml = { - id: { value: 'sh8013' }, + id: { value: 'sh8013disclosure' }, authInfo: { pw: { value: '2fooBAR' } } } - @response = epp_request(update_contact_xml(xml), :xml) + @response = epp_plain_request(update_contact_xml(xml), :xml) - expect(@response[:results][0][:result_code]).to eq('1000') + @response[:results][0][:msg].should == 'Command completed successfully' + @response[:results][0][:result_code].should == '1000' - expect(Contact.last.disclosure.phone).to eq(false) - expect(Contact.last.disclosure.email).to eq(false) - expect(Contact.count).to eq(1) + Contact.last.disclosure.phone.should == false + Contact.last.disclosure.email.should == false end end context 'delete command' do it 'fails if request is invalid' do xml = epp_xml.delete({ uid: { value: '23123' } }) - response = epp_request(xml, :xml) + response = epp_plain_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2003') - expect(response[:results][0][:msg]).to eq('Required parameter missing: id') - expect(response[:results].count).to eq 1 + response[:results][0][:msg].should == 'Required parameter missing: id' + response[:results][0][:result_code].should == '2003' + response[:results].count.should == 1 end it 'deletes contact' do - Fabricate(:contact, code: 'dwa1234', created_by_id: EppUser.first.id, registrar: zone) - response = epp_request(delete_contact_xml({ id: { value: 'dwa1234' } }), :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') - expect(response[:clTRID]).to eq('ABC-12345') + @contact_deleted = + Fabricate(:contact, code: 'dwa1234', created_by_id: EppUser.first.id, registrar: registrar1) - expect(Contact.count).to eq(0) + response = epp_plain_request(delete_contact_xml({ id: { value: 'dwa1234' } }), :xml) + response[:msg].should == 'Command completed successfully' + response[:result_code].should == '1000' + response[:clTRID].should == 'ABC-12345' + + Contact.find_by_id(@contact_deleted.id).should == nil end it 'returns error if obj doesnt exist' do - response = epp_request(delete_contact_xml, :xml) - expect(response[:result_code]).to eq('2303') - expect(response[:msg]).to eq('Object does not exist') + response = epp_plain_request(delete_contact_xml, :xml) + response[:msg].should == 'Object does not exist' + response[:result_code].should == '2303' end it 'fails if contact has associated domain' do Fabricate( :domain, - registrar: zone, + registrar: registrar1, owner_contact: Fabricate( :contact, code: 'dwa1234', - created_by_id: zone.id, - registrar: zone) + created_by_id: registrar1.id, + registrar: registrar1) ) - expect(Domain.first.owner_contact.address.present?).to be true - response = epp_request(delete_contact_xml({ id: { value: 'dwa1234' } }), :xml) + Domain.last.owner_contact.address.present?.should == true + response = epp_plain_request(delete_contact_xml({ id: { value: 'dwa1234' } }), :xml) - expect(response[:result_code]).to eq('2305') - expect(response[:msg]).to eq('Object association prohibits operation') - - expect(Domain.first.owner_contact.present?).to be true + response[:msg].should == 'Object association prohibits operation' + response[:result_code].should == '2305' + Domain.last.owner_contact.present?.should == true end end context 'check command' do it 'fails if request is invalid' do xml = epp_xml.check({ uid: { value: '123asde' } }) - response = epp_request(xml, :xml) + response = epp_plain_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2003') - expect(response[:results][0][:msg]).to eq('Required parameter missing: id') - expect(response[:results].count).to eq 1 + response[:results][0][:msg].should == 'Required parameter missing: id' + response[:results][0][:result_code].should == '2003' + response[:results].count.should == 1 end it 'returns info about contact availability' do Fabricate(:contact, code: 'check-1234') - response = epp_request(check_multiple_contacts_xml, :xml) + response = epp_plain_request(check_multiple_contacts_xml, :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') + response[:msg].should == 'Command completed successfully' + response[:result_code].should == '1000' ids = response[:parsed].css('resData chkData id') - expect(ids[0].attributes['avail'].text).to eq('0') - expect(ids[1].attributes['avail'].text).to eq('1') + ids[0].attributes['avail'].text.should == '0' + ids[1].attributes['avail'].text.should == '1' - expect(ids[0].text).to eq('check-1234') - expect(ids[1].text).to eq('check-4321') + ids[0].text.should == 'check-1234' + ids[1].text.should == 'check-4321' end end context 'info command' do - it 'discloses items with wrong password when queried by owner' do - @contact = Fabricate(:contact, registrar: zone, code: 'info-4444', name: 'Johnny Awesome', auth_info: 'asde', - address: Fabricate(:address), disclosure: Fabricate(:contact_disclosure, name: false)) - - xml = epp_xml.info({ id: { value: @contact.code } }) - response = epp_request(xml, :xml, :zone) - contact = response[:parsed].css('resData chkData') - - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') - expect(contact.css('name').first.text).to eq('Johnny Awesome') + before :all do + @registrar1_contact = Fabricate(:contact, code: 'info-4444', registrar: registrar1) end - it 'returns auth error for non-owner with wrong password' do - @contact = Fabricate(:contact, registrar: elkdata, code: 'info-4444', name: 'Johnny Awesome', auth_info: 'asde', - address: Fabricate(:address), disclosure: Fabricate(:contact_disclosure, name: false)) + # it 'discloses items with wrong password when queried by owner' do + # @contact = Fabricate(:contact, + # registrar: registrar1, code: 'info-4444', + # name: 'Johnny Awesome', auth_info: 'asde', + # address: Fabricate(:address), disclosure: Fabricate(:contact_disclosure, name: false)) - xml = epp_xml.info({ id: { value: @contact.code }, authInfo: { pw: { value: 'asdesde' } } }) - response = epp_request(xml, :xml, :zone) + # xml = epp_xml.info({ id: { value: @contact.code } }) + # login_as :registrar1 do + # response = epp_plain_request(xml, :xml) + # contact = response[:parsed].css('resData chkData') - expect(response[:result_code]).to eq('2200') - expect(response[:msg]).to eq('Authentication error') + # expect(response[:result_code]).to eq('1000') + # expect(response[:msg]).to eq('Command completed successfully') + # expect(contact.css('name').first.text).to eq('Johnny Awesome') + # end + # end + + # it 'returns auth error for non-owner with wrong password' do + # @contact = Fabricate(:contact, + # registrar: registrar2, code: 'info-4444', name: 'Johnny Awesome', auth_info: 'asde', + # address: Fabricate(:address), disclosure: Fabricate(:contact_disclosure, name: false)) + + # xml = epp_xml.info({ id: { value: @contact.code }, authInfo: { pw: { value: 'asdesde' } } }) + # response = epp_plain_request(xml, :xml, :registrar1) + + # expect(response[:result_code]).to eq('2200') + # expect(response[:msg]).to eq('Authentication error') + # end + + # it 'doesn\'t disclose items to non-owner with right password' do + # @contact = Fabricate(:contact, registrar: registrar2, code: 'info-4444', + # name: 'Johnny Awesome', auth_info: 'password', + # address: Fabricate(:address), disclosure: Fabricate(:contact_disclosure, name: false)) + + # xml = epp_xml.info({ id: { value: @contact.code }, authInfo: { pw: { value: 'password' } } }) + # response = epp_plain_request(xml, :xml, :registrar1) + # contact = response[:parsed].css('resData chkData') + + # expect(response[:result_code]).to eq('1000') + # expect(response[:msg]).to eq('Command completed successfully') + # expect(contact.css('chkData postalInfo name').first).to eq(nil) + # end + + # it 'discloses items to owner' do + # @contact = Fabricate(:contact, registrar: registrar1, code: 'info-4444', name: 'Johnny Awesome', + # auth_info: 'password', + # address: Fabricate(:address), disclosure: Fabricate(:contact_disclosure, name: false)) + + # xml = epp_xml.info({ id: { value: @contact.code } }) + # response = epp_plain_request(xml, :xml, :registrar1) + # contact = response[:parsed].css('resData chkData') + + # expect(response[:result_code]).to eq('1000') + # expect(response[:msg]).to eq('Command completed successfully') + # expect(contact.css('name').first.text).to eq('Johnny Awesome') + # end + + # it 'fails if request invalid' do + # response = epp_plain_request(epp_xml.info({ uid: { value: '123123' } }), :xml) + + # expect(response[:results][0][:result_code]).to eq('2003') + # expect(response[:results][0][:msg]).to eq('Required parameter missing: id') + # expect(response[:results].count).to eq 1 + # end + + # it 'returns error when object does not exist' do + # response = epp_plain_request(info_contact_xml({ id: { value: 'info-4444' } }), :xml) + # expect(response[:result_code]).to eq('2303') + # expect(response[:msg]).to eq('Object does not exist') + # expect(response[:results][0][:value]).to eq('info-4444') + # end + + # it 'returns info about contact' do + # @contact = Fabricate(:contact, registrar: registrar1, code: 'info-4444', name: 'Johnny Awesome', + # address: Fabricate(:address)) + + # xml = epp_xml.info(id: { value: @contact.code }) + # response = epp_plain_request(xml, :xml, :registrar1) + # contact = response[:parsed].css('resData chkData') + + # expect(response[:result_code]).to eq('1000') + # expect(response[:msg]).to eq('Command completed successfully') + # expect(contact.css('name').first.text).to eq('Johnny Awesome') + + # end + + # it 'doesn\'t disclose private elements' do + # Fabricate(:contact, code: 'info-4444', auth_info: '2fooBAR', registrar: registrar2, + # disclosure: Fabricate(:contact_disclosure, name: true, email: false, phone: false)) + + # xml = epp_xml.info({ id: { value: 'info-4444' }, authInfo: { pw: { value: '2fooBAR' } } }) + + # response = epp_plain_request(xml, :xml, :registrar1) + # contact = response[:parsed].css('resData chkData') + + # expect(response[:result_code]).to eq('1000') + + # expect(contact.css('chkData phone')).to eq(contact.css('chkData disclose phone')) + # expect(contact.css('chkData phone').count).to eq(1) + # expect(contact.css('chkData email')).to eq(contact.css('chkData disclose email')) + # expect(contact.css('chkData email').count).to eq(1) + # expect(contact.css('postalInfo name').present?).to be(true) + # end + + it 'does not display unassociated object without password' do + # xml = epp_xml.info(id: { value: @registrar1_contact.code }) + # response = epp_plain_request(xml, :xml, :registrar2) + # expect(response[:result_code]).to eq('2003') + # expect(response[:msg]).to eq('Required parameter missing: pw') end - it 'doesn\'t disclose items to non-owner with right password' do - @contact = Fabricate(:contact, registrar: elkdata, code: 'info-4444', - name: 'Johnny Awesome', auth_info: 'password', - address: Fabricate(:address), disclosure: Fabricate(:contact_disclosure, name: false)) + it 'does not display unassociated object with wrong password' do + login_as :registrar2 + xml = epp_xml.info(id: { value: @registrar1_contact.code }, + authInfo: { pw: { value: 'wrong-pw' } }) + response = epp_plain_request(xml, :xml) - xml = epp_xml.info({ id: { value: @contact.code }, authInfo: { pw: { value: 'password' } } }) - response = epp_request(xml, :xml, :zone) - contact = response[:parsed].css('resData chkData') - - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') - expect(contact.css('chkData postalInfo name').first).to eq(nil) - end - - it 'discloses items to owner' do - @contact = Fabricate(:contact, registrar: zone, code: 'info-4444', name: 'Johnny Awesome', - auth_info: 'password', - address: Fabricate(:address), disclosure: Fabricate(:contact_disclosure, name: false)) - - xml = epp_xml.info({ id: { value: @contact.code } }) - response = epp_request(xml, :xml, :zone) - contact = response[:parsed].css('resData chkData') - - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') - expect(contact.css('name').first.text).to eq('Johnny Awesome') - end - - it 'fails if request invalid' do - response = epp_request(epp_xml.info({ uid: { value: '123123' } }), :xml) - - expect(response[:results][0][:result_code]).to eq('2003') - expect(response[:results][0][:msg]).to eq('Required parameter missing: id') - expect(response[:results].count).to eq 1 - end - - it 'returns error when object does not exist' do - response = epp_request(info_contact_xml({ id: { value: 'info-4444' } }), :xml) - expect(response[:result_code]).to eq('2303') - expect(response[:msg]).to eq('Object does not exist') - expect(response[:results][0][:value]).to eq('info-4444') - end - - it 'returns info about contact' do - @contact = Fabricate(:contact, registrar: zone, code: 'info-4444', name: 'Johnny Awesome', - address: Fabricate(:address)) - - xml = epp_xml.info(id: { value: @contact.code }) - response = epp_request(xml, :xml, :zone) - contact = response[:parsed].css('resData chkData') - - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') - expect(contact.css('name').first.text).to eq('Johnny Awesome') - - end - - it 'doesn\'t disclose private elements' do - Fabricate(:contact, code: 'info-4444', auth_info: '2fooBAR', registrar: elkdata, - disclosure: Fabricate(:contact_disclosure, name: true, email: false, phone: false)) - - xml = epp_xml.info({ id: { value: 'info-4444' }, authInfo: { pw: { value: '2fooBAR' } } }) - - response = epp_request(xml, :xml, :zone) - contact = response[:parsed].css('resData chkData') - - expect(response[:result_code]).to eq('1000') - - expect(contact.css('chkData phone')).to eq(contact.css('chkData disclose phone')) - expect(contact.css('chkData phone').count).to eq(1) - expect(contact.css('chkData email')).to eq(contact.css('chkData disclose email')) - expect(contact.css('chkData email').count).to eq(1) - expect(contact.css('postalInfo name').present?).to be(true) - end - - it 'doesn\'t display unassociated object without password' do - @contact = Fabricate(:contact, code: 'info-4444', registrar: zone) - - xml = epp_xml.info(id: { value: @contact.code }) - response = epp_request(xml, :xml, :elkdata) - expect(response[:result_code]).to eq('2003') - expect(response[:msg]).to eq('Required parameter missing: pw') - end - - it 'doesn\'t display unassociated object with wrong password' do - @contact = Fabricate(:contact, code: 'info-4444', registrar: zone) - - xml = epp_xml.info(id: { value: @contact.code }, authInfo: { pw: { value: 'qwe321' } }) - response = epp_request(xml, :xml, :elkdata) - expect(response[:result_code]).to eq('2200') - expect(response[:msg]).to eq('Authentication error') + response[:msg].should == 'Authentication error' + response[:result_code].should == '2200' end end context 'renew command' do it 'returns 2101-unimplemented command' do - response = epp_request('contacts/renew.xml') + response = epp_plain_request('contacts/renew.xml') - expect(response[:result_code]).to eq('2101') - expect(response[:msg]).to eq('Unimplemented command') + response[:msg].should == 'Unimplemented command' + response[:result_code].should == '2101' end end end + + def registrar1 + @registrar1 ||= Registrar.where(reg_no: '12345678').first || Fabricate(:registrar) + end + + def registrar2 + @registrar2 ||= Fabricate(:registrar, { name: 'registrar2', reg_no: '123' }) + end + + def epp_xml + @epp_xml ||= EppXml::Contact.new(cl_trid: 'ABC-12345') + end end diff --git a/spec/epp/domain_spec.rb b/spec/epp/domain_spec.rb index 0f019a776..355c06f09 100644 --- a/spec/epp/domain_spec.rb +++ b/spec/epp/domain_spec.rb @@ -1,451 +1,323 @@ require 'rails_helper' describe 'EPP Domain', epp: true do - before do - # we don't really care about the code validations here, it's done in models - # dynamic Contact.code just makes it harder to test EPP - Contact.skip_callback(:create, :before, :generate_code) - end - - after do - Contact.set_callback(:create, :before, :generate_code) - end - - let(:server_zone) { Epp::Server.new({ server: 'localhost', tag: 'zone', password: 'ghyt9e4fu', port: 701 }) } - let(:server_elkdata) { Epp::Server.new({ server: 'localhost', tag: 'elkdata', password: 'ghyt9e4fu', port: 701 }) } - let(:elkdata) { Fabricate(:registrar, { name: 'Elkdata', reg_no: '123' }) } - let(:zone) { Fabricate(:registrar) } let(:epp_xml) { EppXml.new(cl_trid: 'ABC-12345') } - before(:each) { create_settings } + def registrar1 + @registrar1 ||= Registrar.where(reg_no: '12345678').first || Fabricate(:registrar) + end - context 'with valid user' do - before(:each) do - Fabricate(:epp_user, username: 'zone', registrar: zone) - Fabricate(:epp_user, username: 'elkdata', registrar: elkdata) + def registrar2 + @registrar2 ||= Fabricate(:registrar, { name: 'registrar2', reg_no: '123' }) + end + + before(:all) do + Fabricate(:epp_user, username: 'registrar1', registrar: registrar1) + Fabricate(:epp_user, username: 'registrar2', registrar: registrar2) + + login_as :registrar1 + + Contact.skip_callback(:create, :before, :generate_code) + + Fabricate(:contact, code: 'citizen_1234') + Fabricate(:contact, code: 'sh8013') + Fabricate(:contact, code: 'sh801333') + Fabricate(:contact, code: 'juridical_1234', ident_type: 'ico') + Fabricate(:reserved_domain) + + @uniq_no = proc { @i ||= 0; @i += 1 } + + create_settings + end + + it 'returns error if contact does not exists' do + response = epp_plain_request(domain_create_xml({ + registrant: { value: 'citizen_1234' }, + _anonymus: [ + { contact: { value: 'citizen_1234', attrs: { type: 'admin' } } }, + { contact: { value: 'sh1111', attrs: { type: 'tech' } } }, + { contact: { value: 'sh2222', attrs: { type: 'tech' } } } + ] + }), :xml) + + response[:results][0][:result_code].should == '2303' + response[:results][0][:msg].should == 'Contact was not found' + response[:results][0][:value].should == 'sh1111' + + response[:results][1][:result_code].should == '2303' + response[:results][1][:msg].should == 'Contact was not found' + response[:results][1][:value].should == 'sh2222' + + response[:clTRID].should == 'ABC-12345' + + log = ApiLog::EppLog.last + + log.request_command.should == 'create' + log.request_object.should == 'domain' + log.request_successful.should == false + log.api_user_name.should == 'registrar1' + log.api_user_registrar.should == 'Registrar OÜ' + log.request.should_not be_blank + log.response.should_not be_blank + end + + it 'validates required parameters' do + epp_xml = EppXml::Domain.new(cl_trid: 'ABC-12345') + xml = epp_xml.create({ + name: { value: 'test.ee' } + }) + + response = epp_plain_request(xml, :xml) + response[:results][0][:result_code].should == '2003' + response[:results][0][:msg].should == 'Required parameter missing: ns' + + response[:results][1][:result_code].should == '2003' + response[:results][1][:msg].should == 'Required parameter missing: registrant' + + response[:results][2][:result_code].should == '2003' + response[:results][2][:msg].should == 'Required parameter missing: ns > hostAttr' + + response[:results][3][:result_code].should == '2003' + response[:results][3][:msg].should == 'Required parameter missing: extension > extdata > legalDocument' + end + + context 'with citizen as an owner' do + it 'creates a domain' do + dn = next_domain_name + response = epp_plain_request(domain_create_xml({ + name: { value: dn } + }), :xml) + d = Domain.last + response[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' + + cre_data = response[:parsed].css('creData') + + cre_data.css('name').text.should == dn + cre_data.css('crDate').text.should == d.created_at.to_time.utc.to_s + cre_data.css('exDate').text.should == d.valid_to.to_time.utc.to_s + + response[:clTRID].should == 'ABC-12345' + + d.registrar.name.should == 'Registrar OÜ' + d.tech_contacts.count.should == 2 + d.admin_contacts.count.should == 1 + + d.nameservers.count.should == 2 + d.auth_info.should_not be_empty + + d.dnskeys.count.should == 1 + + key = d.dnskeys.last + + key.ds_alg.should == 3 + key.ds_key_tag.should_not be_blank + + key.ds_digest_type.should == Setting.ds_algorithm + key.flags.should == 257 + key.protocol.should == 3 + key.alg.should == 5 + key.public_key.should == 'AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8' end - it 'returns error if contact does not exists' do - Fabricate(:contact, code: 'jd1234') + it 'creates a domain with legal document' do + response = epp_plain_request(domain_create_xml_with_legal_doc, :xml) - response = epp_request(domain_create_xml, :xml) - - expect(response[:results][0][:result_code]).to eq('2303') - expect(response[:results][0][:msg]).to eq('Contact was not found') - expect(response[:results][0][:value]).to eq('sh8013') - - expect(response[:results][1][:result_code]).to eq('2303') - expect(response[:results][1][:msg]).to eq('Contact was not found') - expect(response[:results][1][:value]).to eq('sh801333') - - expect(response[:clTRID]).to eq('ABC-12345') - - log = ApiLog::EppLog.all - - expect(log.length).to eq(4) - expect(log[0].request_command).to eq('hello') - expect(log[0].request_successful).to eq(true) - - expect(log[1].request_command).to eq('login') - expect(log[1].request_successful).to eq(true) - expect(log[1].api_user_name).to eq('zone') - expect(log[1].api_user_registrar).to eq('Registrar OÜ') - - expect(log[2].request_command).to eq('create') - expect(log[2].request_object).to eq('domain') - expect(log[2].request_successful).to eq(false) - expect(log[2].api_user_name).to eq('zone') - expect(log[2].api_user_registrar).to eq('Registrar OÜ') - expect(log[2].request).not_to be_blank - expect(log[2].response).not_to be_blank - - expect(log[3].request_command).to eq('logout') - expect(log[3].request_successful).to eq(true) - expect(log[3].api_user_name).to eq('zone') - expect(log[3].api_user_registrar).to eq('Registrar OÜ') + response[:msg].should == 'Command completed successfully' + response[:result_code].should == '1000' + d = Domain.last + d.legal_documents.count.should == 1 end - it 'validates required parameters' do - epp_xml = EppXml::Domain.new(cl_trid: 'ABC-12345') - xml = epp_xml.create({ - name: { value: 'test.ee' } - }) - - response = epp_request(xml, :xml) - - expect(response[:results][0][:result_code]).to eq('2003') - expect(response[:results][0][:msg]).to eq('Required parameter missing: ns') - - expect(response[:results][1][:result_code]).to eq('2003') - expect(response[:results][1][:msg]).to eq('Required parameter missing: registrant') - - expect(response[:results][2][:result_code]).to eq('2003') - expect(response[:results][2][:msg]).to eq('Required parameter missing: ns > hostAttr') - - expect(response[:results][3][:result_code]).to eq('2003') - expect(response[:results][3][:msg]).to eq('Required parameter missing: extension > extdata > legalDocument') - end - - context 'with citizen as an owner' do - before(:each) do - Fabricate(:contact, code: 'jd1234') - Fabricate(:contact, code: 'sh8013') - Fabricate(:contact, code: 'sh801333') - end - - it 'creates a domain' do - response = epp_request(domain_create_xml, :xml) - d = Domain.first - - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') - - cre_data = response[:parsed].css('creData') - - expect(cre_data.css('name').text).to eq('example.ee') - expect(cre_data.css('crDate').text).to eq(d.created_at.to_time.utc.to_s) - expect(cre_data.css('exDate').text).to eq(d.valid_to.to_time.utc.to_s) - - expect(response[:clTRID]).to eq('ABC-12345') - - expect(d.registrar.name).to eq('Registrar OÜ') - expect(d.tech_contacts.count).to eq 2 - expect(d.admin_contacts.count).to eq 1 - - expect(d.nameservers.count).to eq(2) - expect(d.auth_info).not_to be_empty - - expect(d.dnskeys.count).to eq(1) - - key = d.dnskeys.first - - expect(key.ds_alg).to eq(3) - expect(key.ds_key_tag).to_not be_blank - - expect(key.ds_digest_type).to eq(Setting.ds_algorithm) - expect(key.flags).to eq(257) - expect(key.protocol).to eq(3) - expect(key.alg).to eq(5) - expect(key.public_key).to eq('AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8') - end - - it 'creates a domain with legal document' do - response = epp_request(domain_create_xml_with_legal_doc, :xml) - - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') - d = Domain.first - expect(d.legal_documents.count).to eq(1) - end - - it 'creates ria.ee with valid ds record' do - xml = domain_create_xml({ - name: { value: 'ria.ee' } - }, { - _anonymus: [ - { keyData: { - flags: { value: '257' }, - protocol: { value: '3' }, - alg: { value: '8' }, - pubKey: { value: 'AwEAAaOf5+lz3ftsL+0CCvfJbhUF/NVsNh8BKo61oYs5fXVbuWDiH872 '\ - 'LC8uKDO92TJy7Q4TF9XMAKMMlf1GMAxlRspD749SOCTN00sqfWx1OMTu '\ - 'a28L1PerwHq7665oDJDKqR71btcGqyLKhe2QDvCdA0mENimF1NudX1BJ '\ - 'DDFi6oOZ0xE/0CuveB64I3ree7nCrwLwNs56kXC4LYoX3XdkOMKiJLL/ '\ - 'MAhcxXa60CdZLoRtTEW3z8/oBq4hEAYMCNclpbd6y/exScwBxFTdUfFk '\ - 'KsdNcmvai1lyk9vna0WQrtpYpHKMXvY9LFHaJxCOLR4umfeQ42RuTd82 lqfU6ClMeXs=' } - } - } - ] - }) - - epp_request(xml, :xml) - d = Domain.first - ds = d.dnskeys.first - expect(ds.ds_digest).to eq('0B62D1BC64EFD1EE652FB102BDF1011BF514CCD9A1A0CFB7472AEA3B01F38C92') - end - - it 'validates nameserver ipv4 when in same zone as domain' do - xml = domain_create_xml({ - ns: [ - { - hostAttr: [ - { hostName: { value: 'ns1.example.ee' } } - ] - }, - { - hostAttr: { - hostName: { value: 'ns2.example.ee' } - } - } - ] - }) - - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2306') - expect(response[:msg]).to eq('IPv4 is missing') - end - - it 'does not create duplicate domain' do - epp_request(domain_create_xml, :xml) - response = epp_request(domain_create_xml, :xml) - expect(response[:result_code]).to eq('2302') - expect(response[:msg]).to eq('Domain name already exists') - expect(response[:clTRID]).to eq('ABC-12345') - end - - it 'does not create reserved domain' do - Fabricate(:reserved_domain) - - xml = domain_create_xml(name: { value: '1162.ee' }) - - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2302') - expect(response[:msg]).to eq('Domain name is reserved or restricted') - expect(response[:clTRID]).to eq('ABC-12345') - end - - it 'does not create domain without contacts and registrant' do - xml = domain_create_xml(contacts: [], registrant: false) - - response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2003') - expect(response[:results][0][:msg]).to eq('Required parameter missing: registrant') - end - - it 'does not create domain without nameservers' do - xml = domain_create_xml(ns: []) - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2003') - expect(response[:msg]).to eq('Required parameter missing: ns') - end - - it 'does not create domain with too many nameservers' do - nameservers = [] - 14.times do |i| - nameservers << { - hostAttr: { - hostName: { value: "ns#{i}.example.net" } + it 'creates ria.ee with valid ds record' do + xml = domain_create_xml({ + name: { value: 'ria.ee' } + }, { + _anonymus: [ + { keyData: { + flags: { value: '257' }, + protocol: { value: '3' }, + alg: { value: '8' }, + pubKey: { value: 'AwEAAaOf5+lz3ftsL+0CCvfJbhUF/NVsNh8BKo61oYs5fXVbuWDiH872 '\ + 'LC8uKDO92TJy7Q4TF9XMAKMMlf1GMAxlRspD749SOCTN00sqfWx1OMTu '\ + 'a28L1PerwHq7665oDJDKqR71btcGqyLKhe2QDvCdA0mENimF1NudX1BJ '\ + 'DDFi6oOZ0xE/0CuveB64I3ree7nCrwLwNs56kXC4LYoX3XdkOMKiJLL/ '\ + 'MAhcxXa60CdZLoRtTEW3z8/oBq4hEAYMCNclpbd6y/exScwBxFTdUfFk '\ + 'KsdNcmvai1lyk9vna0WQrtpYpHKMXvY9LFHaJxCOLR4umfeQ42RuTd82 lqfU6ClMeXs=' } } } - end - xml = domain_create_xml(ns: nameservers) + ] + }) - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2004') - expect(response[:msg]).to eq('Nameservers count must be between 2-11') - end + epp_plain_request(xml, :xml) + d = Domain.last + ds = d.dnskeys.last + ds.ds_digest.should == '0B62D1BC64EFD1EE652FB102BDF1011BF514CCD9A1A0CFB7472AEA3B01F38C92' + end - it 'returns error when invalid nameservers are present' do - xml = domain_create_xml({ - ns: [ - { - hostAttr: { - hostName: { value: 'invalid1-' } - } - }, - { - hostAttr: { - hostName: { value: '-invalid2' } - } + it 'validates nameserver ipv4 when in same zone as domain' do + dn = next_domain_name + xml = domain_create_xml({ + name: { value: dn }, + ns: [ + { + hostAttr: [ + { hostName: { value: "ns1.#{dn}" } } + ] + }, + { + hostAttr: { + hostName: { value: "ns2.#{dn}" } } - ] - }) + } + ] + }) - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2005') - expect(response[:msg]).to eq('Hostname is invalid') + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2306' + response[:msg].should == 'IPv4 is missing' + end + + it 'does not create duplicate domain' do + dn = next_domain_name + epp_plain_request(domain_create_xml({ + name: { value: dn } + }), :xml) + response = epp_plain_request(domain_create_xml({ + name: { value: dn } + }), :xml) + + response[:result_code].should == '2302' + response[:msg].should == 'Domain name already exists' + response[:clTRID].should == 'ABC-12345' + end + + it 'does not create reserved domain' do + xml = domain_create_xml(name: { value: '1162.ee' }) + + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2302' + response[:msg].should == 'Domain name is reserved or restricted' + response[:clTRID].should == 'ABC-12345' + end + + it 'does not create domain without contacts and registrant' do + xml = domain_create_xml(contacts: [], registrant: false) + + response = epp_plain_request(xml, :xml) + response[:results][0][:result_code].should == '2003' + response[:results][0][:msg].should == 'Required parameter missing: registrant' + end + + it 'does not create domain without nameservers' do + xml = domain_create_xml(ns: []) + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2003' + response[:msg].should == 'Required parameter missing: ns' + end + + it 'does not create domain with too many nameservers' do + nameservers = [] + 14.times do |i| + nameservers << { + hostAttr: { + hostName: { value: "ns#{i}.example.net" } + } + } end - it 'checks hostAttr presence' do - xml = domain_create_xml({ - ns: [ - { - hostObj: { value: 'ns1.example.ee' } - }, - { - hostObj: { value: 'ns2.example.ee' } + xml = domain_create_xml({ + ns: nameservers + }) + + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2004' + response[:msg].should == 'Nameservers count must be between 2-11' + end + + it 'returns error when invalid nameservers are present' do + xml = domain_create_xml({ + ns: [ + { + hostAttr: { + hostName: { value: 'invalid1-' } } - ] - }) - - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2003') - expect(response[:msg]).to eq('Required parameter missing: ns > hostAttr') - end - - it 'creates domain with nameservers with ips' do - epp_request(domain_create_with_host_attrs, :xml) - expect(Domain.first.nameservers.count).to eq(2) - ns = Domain.first.nameservers.first - expect(ns.ipv4).to eq('192.0.2.2') - expect(ns.ipv6).to eq('1080:0:0:0:8:800:200C:417A') - end - - it 'returns error when nameserver has invalid ips' do - response = epp_request(domain_create_with_invalid_ns_ip_xml, :xml) - expect(response[:results][0][:result_code]).to eq '2005' - expect(response[:results][0][:msg]).to eq 'IPv4 is invalid' - expect(response[:results][0][:value]).to eq '192.0.2.2.invalid' - expect(response[:results][1][:result_code]).to eq '2005' - expect(response[:results][1][:msg]).to eq 'IPv6 is invalid' - expect(response[:results][1][:value]).to eq 'INVALID_IPV6' - expect(Domain.count).to eq(0) - expect(Nameserver.count).to eq(0) - end - - it 'creates a domain with period in days' do - xml = domain_create_xml(period_value: 365, period_unit: 'd') - - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') - expect(Domain.first.valid_to).to eq(Date.today + 1.year) - end - - it 'does not create a domain with invalid period' do - xml = domain_create_xml({ - period: { value: '367', attrs: { unit: 'd' } } - }) - - response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2004') - expect(response[:results][0][:msg]).to eq('Period must add up to 1, 2 or 3 years') - expect(response[:results][0][:value]).to eq('367') - end - - it 'creates a domain with multiple dnskeys' do - xml = domain_create_xml({}, { - _anonymus: [ - { keyData: { - flags: { value: '257' }, - protocol: { value: '3' }, - alg: { value: '3' }, - pubKey: { value: 'AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8' } - } - }, - { - keyData: { - flags: { value: '0' }, - protocol: { value: '3' }, - alg: { value: '5' }, - pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } - } - }, - { - keyData: { - flags: { value: '256' }, - protocol: { value: '3' }, - alg: { value: '254' }, - pubKey: { value: '841936717ae427ace63c28d04918569a841936717ae427ace63c28d0' } - } + }, + { + hostAttr: { + hostName: { value: '-invalid2' } } - ] - }) + } + ] + }) - epp_request(xml, :xml) - d = Domain.first + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2005' + response[:msg].should == 'Hostname is invalid' + end - expect(d.dnskeys.count).to eq(3) + it 'checks hostAttr presence' do + xml = domain_create_xml({ + ns: [ + { + hostObj: { value: 'ns1.example.ee' } + }, + { + hostObj: { value: 'ns2.example.ee' } + } + ] + }) - key_1 = d.dnskeys[0] - expect(key_1.ds_key_tag).to_not be_blank - expect(key_1.ds_alg).to eq(3) - expect(key_1.ds_digest_type).to eq(Setting.ds_algorithm) + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2003' + response[:msg].should == 'Required parameter missing: ns > hostAttr' + end - expect(d.dnskeys.pluck(:flags)).to match_array([257, 0, 256]) - expect(d.dnskeys.pluck(:protocol)).to match_array([3, 3, 3]) - expect(d.dnskeys.pluck(:alg)).to match_array([3, 5, 254]) - expect(d.dnskeys.pluck(:public_key)).to match_array(%w( - AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8 - 700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f - 841936717ae427ace63c28d04918569a841936717ae427ace63c28d0 - )) - end + it 'creates domain with nameservers with ips' do + epp_plain_request(domain_create_with_host_attrs, :xml) + Domain.last.nameservers.count.should == 2 + ns = Domain.last.nameservers.first + ns.ipv4.should == '192.0.2.2' + ns.ipv6.should == '1080:0:0:0:8:800:200C:417A' + end - it 'does not create a domain when dnskeys are invalid' do + it 'returns error when nameserver has invalid ips' do + domain_count = Domain.count + nameserver_count = Nameserver.count + response = epp_plain_request(domain_create_with_invalid_ns_ip_xml, :xml) + response[:results][0][:result_code].should == '2005' + response[:results][0][:msg].should == 'IPv4 is invalid' + response[:results][0][:value].should == '192.0.2.2.invalid' + response[:results][1][:result_code].should == '2005' + response[:results][1][:msg].should == 'IPv6 is invalid' + response[:results][1][:value].should == 'INVALID_IPV6' + # ensure nothing gets saved to db: + Domain.count.should == domain_count + Nameserver.count.should == nameserver_count + end - xml = domain_create_xml({}, { - _anonymus: [ - { keyData: { - flags: { value: '250' }, - protocol: { value: '4' }, - alg: { value: '9' }, - pubKey: { value: 'AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8' } - } - }, - { - keyData: { - flags: { value: '1' }, - protocol: { value: '3' }, - alg: { value: '10' }, - pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } - } - }, - { - keyData: { - flags: { value: '256' }, - protocol: { value: '5' }, - alg: { value: '254' }, - pubKey: { value: '' } - } - } - ] - }) + it 'creates a domain with period in days' do + xml = domain_create_xml(period_value: 365, period_unit: 'd') - response = epp_request(xml, :xml) + response = epp_plain_request(xml, :xml) + response[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' + Domain.first.valid_to.should == Date.today + 1.year + end - expect(response[:results][0][:msg]).to eq('Valid algorithms are: 3, 5, 6, 7, 8, 252, 253, 254, 255') - expect(response[:results][0][:value]).to eq('9') + it 'does not create a domain with invalid period' do + xml = domain_create_xml({ + period: { value: '367', attrs: { unit: 'd' } } + }) - expect(response[:results][1][:msg]).to eq('Valid protocols are: 3') - expect(response[:results][1][:value]).to eq('4') + response = epp_plain_request(xml, :xml) + response[:results][0][:result_code].should == '2004' + response[:results][0][:msg].should == 'Period must add up to 1, 2 or 3 years' + response[:results][0][:value].should == '367' + end - expect(response[:results][2][:msg]).to eq('Valid flags are: 0, 256, 257') - expect(response[:results][2][:value]).to eq('250') - - expect(response[:results][3][:msg]).to eq('Valid algorithms are: 3, 5, 6, 7, 8, 252, 253, 254, 255') - expect(response[:results][3][:value]).to eq('10') - - expect(response[:results][4][:msg]).to eq('Valid flags are: 0, 256, 257') - expect(response[:results][4][:value]).to eq('1') - - expect(response[:results][5][:msg]).to eq('Public key is missing') - - expect(response[:results][6][:msg]).to eq('Valid protocols are: 3') - expect(response[:results][6][:value]).to eq('5') - end - - it 'does not create a domain with two identical dnskeys' do - xml = domain_create_xml({}, { - _anonymus: [ - { keyData: { - flags: { value: '257' }, - protocol: { value: '3' }, - alg: { value: '3' }, - pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } - } - }, - { - keyData: { - flags: { value: '0' }, - protocol: { value: '3' }, - alg: { value: '5' }, - pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } - } - }] - }) - - response = epp_request(xml, :xml) - - expect(response[:result_code]).to eq('2302') - expect(response[:msg]).to eq('Public key already exists') - expect(response[:results][0][:value]).to eq('700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f') - end - - it 'validated dnskeys count' do - Setting.dnskeys_max_count = 1 - - xml = domain_create_xml({}, { + it 'creates a domain with multiple dnskeys' do + xml = domain_create_xml({}, { _anonymus: [ { keyData: { flags: { value: '257' }, @@ -461,945 +333,1162 @@ describe 'EPP Domain', epp: true do alg: { value: '5' }, pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } } + }, + { + keyData: { + flags: { value: '256' }, + protocol: { value: '3' }, + alg: { value: '254' }, + pubKey: { value: '841936717ae427ace63c28d04918569a841936717ae427ace63c28d0' } + } + } + ] + }) + + epp_plain_request(xml, :xml) + d = Domain.last + + d.dnskeys.count.should == 3 + + key_1 = d.dnskeys[0] + key_1.ds_key_tag.should_not be_blank + key_1.ds_alg.should == 3 + key_1.ds_digest_type.should == Setting.ds_algorithm + + d.dnskeys.pluck(:flags).should match_array([257, 0, 256]) + d.dnskeys.pluck(:protocol).should match_array([3, 3, 3]) + d.dnskeys.pluck(:alg).should match_array([3, 5, 254]) + d.dnskeys.pluck(:public_key).should match_array(%w( + AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8 + 700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f + 841936717ae427ace63c28d04918569a841936717ae427ace63c28d0 + )) + end + + it 'does not create a domain when dnskeys are invalid' do + + xml = domain_create_xml({}, { + _anonymus: [ + { keyData: { + flags: { value: '250' }, + protocol: { value: '4' }, + alg: { value: '9' }, + pubKey: { value: 'AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8' } + } + }, + { + keyData: { + flags: { value: '1' }, + protocol: { value: '3' }, + alg: { value: '10' }, + pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } + } + }, + { + keyData: { + flags: { value: '256' }, + protocol: { value: '5' }, + alg: { value: '254' }, + pubKey: { value: '' } + } + } + ] + }) + + response = epp_plain_request(xml, :xml) + + response[:results][0][:msg].should == 'Valid algorithms are: 3, 5, 6, 7, 8, 252, 253, 254, 255' + response[:results][0][:value].should == '9' + + response[:results][1][:msg].should == 'Valid protocols are: 3' + response[:results][1][:value].should == '4' + + response[:results][2][:msg].should == 'Valid flags are: 0, 256, 257' + response[:results][2][:value].should == '250' + + response[:results][3][:msg].should == 'Valid algorithms are: 3, 5, 6, 7, 8, 252, 253, 254, 255' + response[:results][3][:value].should == '10' + + response[:results][4][:msg].should == 'Valid flags are: 0, 256, 257' + response[:results][4][:value].should == '1' + + response[:results][5][:msg].should == 'Public key is missing' + + response[:results][6][:msg].should == 'Valid protocols are: 3' + response[:results][6][:value].should == '5' + end + + it 'does not create a domain with two identical dnskeys' do + xml = domain_create_xml({}, { + _anonymus: [ + { keyData: { + flags: { value: '257' }, + protocol: { value: '3' }, + alg: { value: '3' }, + pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } + } + }, + { + keyData: { + flags: { value: '0' }, + protocol: { value: '3' }, + alg: { value: '5' }, + pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } + } + }] + }) + + response = epp_plain_request(xml, :xml) + + response[:result_code].should == '2302' + response[:msg].should == 'Public key already exists' + response[:results][0][:value].should == '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' + end + + it 'validated dnskeys count' do + Setting.dnskeys_max_count = 1 + + xml = domain_create_xml({}, { + _anonymus: [ + { keyData: { + flags: { value: '257' }, + protocol: { value: '3' }, + alg: { value: '3' }, + pubKey: { value: 'AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8' } + } + }, + { + keyData: { + flags: { value: '0' }, + protocol: { value: '3' }, + alg: { value: '5' }, + pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } + } + }] + }) + + response = epp_plain_request(xml, :xml) + + response[:result_code].should == '2004' + response[:msg].should == 'DNS keys count must be between 0-1' + + create_settings + end + + it 'creates domain with ds data' do + xml = domain_create_xml({}, { + _anonymus: [ + { dsData: { + keyTag: { value: '12345' }, + alg: { value: '3' }, + digestType: { value: '1' }, + digest: { value: '49FD46E6C4B45C55D4AC' } + } }] }) - response = epp_request(xml, :xml) + epp_plain_request(xml, :xml) - expect(response[:result_code]).to eq('2004') - expect(response[:msg]).to eq('DNS keys count must be between 0-1') - end + d = Domain.last + ds = d.dnskeys.first + ds.ds_key_tag.should == '12345' + ds.ds_alg.should == 3 + ds.ds_digest_type.should == 1 + ds.ds_digest.should == '49FD46E6C4B45C55D4AC' + ds.flags.should be_nil + ds.protocol.should be_nil + ds.alg.should be_nil + ds.public_key.should be_nil + end - it 'creates domain with ds data' do - xml = domain_create_xml({}, { - _anonymus: [ - { dsData: { - keyTag: { value: '12345' }, - alg: { value: '3' }, - digestType: { value: '1' }, - digest: { value: '49FD46E6C4B45C55D4AC' } + it 'creates domain with ds data with key' do + xml = domain_create_xml({}, { + _anonymus: [ + { dsData: { + keyTag: { value: '12345' }, + alg: { value: '3' }, + digestType: { value: '1' }, + digest: { value: '49FD46E6C4B45C55D4AC' }, + keyData: { + flags: { value: '0' }, + protocol: { value: '3' }, + alg: { value: '5' }, + pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } } - }] - }) + } + }] + }) - epp_request(xml, :xml) + epp_plain_request(xml, :xml) - d = Domain.first - ds = d.dnskeys.first - expect(ds.ds_key_tag).to eq('12345') - expect(ds.ds_alg).to eq(3) - expect(ds.ds_digest_type).to eq(1) - expect(ds.ds_digest).to eq('49FD46E6C4B45C55D4AC') - expect(ds.flags).to be_nil - expect(ds.protocol).to be_nil - expect(ds.alg).to be_nil - expect(ds.public_key).to be_nil - end + d = Domain.last + ds = d.dnskeys.first + ds.ds_key_tag.should == '12345' + ds.ds_alg.should == 3 + ds.ds_digest_type.should == 1 + ds.ds_digest.should == '49FD46E6C4B45C55D4AC' + ds.flags.should == 0 + ds.protocol.should == 3 + ds.alg.should == 5 + ds.public_key.should == '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' + end - it 'creates domain with ds data with key' do - xml = domain_create_xml({}, { - _anonymus: [ - { dsData: { - keyTag: { value: '12345' }, - alg: { value: '3' }, - digestType: { value: '1' }, - digest: { value: '49FD46E6C4B45C55D4AC' }, - keyData: { - flags: { value: '0' }, - protocol: { value: '3' }, - alg: { value: '5' }, - pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } - } + it 'prohibits dsData with key' do + Setting.ds_data_with_key_allowed = false + + xml = domain_create_xml({}, { + _anonymus: [ + { dsData: { + keyTag: { value: '12345' }, + alg: { value: '3' }, + digestType: { value: '1' }, + digest: { value: '49FD46E6C4B45C55D4AC' }, + keyData: { + flags: { value: '0' }, + protocol: { value: '3' }, + alg: { value: '5' }, + pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } } - }] - }) + } + }] + }) - epp_request(xml, :xml) + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2306' + response[:msg].should == 'dsData object with key data is not allowed' - d = Domain.first - ds = d.dnskeys.first - expect(ds.ds_key_tag).to eq('12345') - expect(ds.ds_alg).to eq(3) - expect(ds.ds_digest_type).to eq(1) - expect(ds.ds_digest).to eq('49FD46E6C4B45C55D4AC') - expect(ds.flags).to eq(0) - expect(ds.protocol).to eq(3) - expect(ds.alg).to eq(5) - expect(ds.public_key).to eq('700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f') - end + create_settings + end - it 'prohibits dsData with key' do - Setting.ds_data_with_key_allowed = false + it 'prohibits dsData' do + Setting.ds_data_allowed = false - xml = domain_create_xml({}, { - _anonymus: [ - { dsData: { - keyTag: { value: '12345' }, - alg: { value: '3' }, - digestType: { value: '1' }, - digest: { value: '49FD46E6C4B45C55D4AC' }, - keyData: { - flags: { value: '0' }, - protocol: { value: '3' }, - alg: { value: '5' }, - pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } - } + xml = domain_create_xml({}, { + _anonymus: [ + { dsData: { + keyTag: { value: '12345' }, + alg: { value: '3' }, + digestType: { value: '1' }, + digest: { value: '49FD46E6C4B45C55D4AC' }, + keyData: { + flags: { value: '0' }, + protocol: { value: '3' }, + alg: { value: '5' }, + pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } } - }] - }) + } + }] + }) - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2306') - expect(response[:msg]).to eq('dsData object with key data is not allowed') - end + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2306' + response[:msg].should == 'dsData object is not allowed' - it 'prohibits dsData' do - Setting.ds_data_allowed = false + create_settings + end - xml = domain_create_xml({}, { - _anonymus: [ - { dsData: { - keyTag: { value: '12345' }, - alg: { value: '3' }, - digestType: { value: '1' }, - digest: { value: '49FD46E6C4B45C55D4AC' }, - keyData: { - flags: { value: '0' }, - protocol: { value: '3' }, - alg: { value: '5' }, - pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } - } - } - }] - }) + it 'prohibits keyData' do + Setting.key_data_allowed = false - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2306') - expect(response[:msg]).to eq('dsData object is not allowed') - end + xml = domain_create_xml({}, { + _anonymus: [ + keyData: { + flags: { value: '0' }, + protocol: { value: '3' }, + alg: { value: '5' }, + pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } + }] + }) - it 'prohibits keyData' do - Setting.key_data_allowed = false + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2306' + response[:msg].should == 'keyData object is not allowed' - xml = domain_create_xml({}, { - _anonymus: [ + create_settings + end + + it 'prohibits dsData and keyData when they exists together' do + xml = domain_create_xml({}, { + _anonymus: [ + { + dsData: { + keyTag: { value: '12345' }, + alg: { value: '3' }, + digestType: { value: '1' }, + digest: { value: '49FD46E6C4B45C55D4AC' } + } + }, + { keyData: { flags: { value: '0' }, protocol: { value: '3' }, alg: { value: '5' }, pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } - }] - }) + } + }] + }) - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2306') - expect(response[:msg]).to eq('keyData object is not allowed') + response = epp_plain_request(xml, :xml) + response[:msg].should == 'Mutually exclusive parameters: keyData, dsData' + response[:result_code].should == '2306' + end + end + + context 'with juridical persion as an owner' do + it 'creates a domain with contacts' do + xml = domain_create_xml({ + registrant: { value: 'juridical_1234' }, + _anonymus: [ + { contact: { value: 'sh8013', attrs: { type: 'admin' } } } + ] + }) + + response = epp_plain_request(xml, :xml) + response[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' + response[:clTRID].should == 'ABC-12345' + + Domain.last.tech_contacts.count.should == 1 + Domain.last.admin_contacts.count.should == 1 + + tech_contact = Domain.last.tech_contacts.first + tech_contact.code.should == 'juridical_1234' + end + + it 'does not create a domain without admin contact' do + domain_count = Domain.count + domain_contact_count = DomainContact.count + xml = domain_create_xml({ + registrant: { value: 'juridical_1234' }, + _anonymus: [ + { contact: { value: 'sh8013', attrs: { type: 'tech' } } } + ] + }) + + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2004' + response[:msg].should == 'Admin contacts count must be between 1-10' + response[:clTRID].should == 'ABC-12345' + + Domain.count.should == domain_count + DomainContact.count.should == domain_contact_count + end + + it 'cannot assign juridical person as admin contact' do + xml = domain_create_xml({ + registrant: { value: 'juridical_1234' }, + _anonymus: [ + { contact: { value: 'juridical_1234', attrs: { type: 'admin' } } } + ] + }) + + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2306' + response[:msg].should == 'Admin contact can be only citizen' + end + end + + context 'with valid domain' do + before(:each) { Fabricate(:domain, name: next_domain_name, registrar: registrar1, dnskeys: []) } + let(:domain) { Domain.last } + + ### TRANSFER ### + it 'transfers a domain' do + domain.registrar = registrar1 + domain.save + + pw = domain.auth_info + xml = domain_transfer_xml({ + name: { value: domain.name }, + authInfo: { pw: { value: pw } } + }) + + response = login_as :registrar2 do + epp_plain_request(xml, :xml) + end + + domain.reload + dtl = domain.domain_transfers.last + + trn_data = response[:parsed].css('trnData') + trn_data.css('name').text.should == domain.name + trn_data.css('trStatus').text.should == 'serverApproved' + trn_data.css('reID').text.should == '123' + trn_data.css('reDate').text.should == dtl.transfer_requested_at.to_time.utc.to_s + trn_data.css('acID').text.should == '12345678' + trn_data.css('acDate').text.should == dtl.transferred_at.to_time.utc.to_s + trn_data.css('exDate').text.should == domain.valid_to.to_time.utc.to_s + + domain.registrar.should == registrar2 + + Setting.transfer_wait_time = 1 + + domain.reload + pw = domain.auth_info + xml = domain_transfer_xml({ + name: { value: domain.name }, + authInfo: { pw: { value: pw } } + }) # request with new password + + response = epp_plain_request(xml, :xml) + trn_data = response[:parsed].css('trnData') + + domain.reload + dtl = domain.domain_transfers.last + + domain.domain_transfers.count.should == 2 + + trn_data.css('name').text.should == domain.name + trn_data.css('trStatus').text.should == 'pending' + trn_data.css('reID').text.should == '12345678' + trn_data.css('reDate').text.should == dtl.transfer_requested_at.to_time.utc.to_s + trn_data.css('acDate').text.should == dtl.wait_until.to_time.utc.to_s + trn_data.css('acID').text.should == '123' + trn_data.css('exDate').text.should == domain.valid_to.to_time.utc.to_s + + domain.registrar.should == registrar2 + + # should return same data if pending already + response = epp_plain_request(xml, :xml) + trn_data = response[:parsed].css('trnData') + + domain.domain_transfers.count.should == 2 + trn_data.css('name').text.should == domain.name + trn_data.css('trStatus').text.should == 'pending' + trn_data.css('reID').text.should == '12345678' + trn_data.css('reDate').text.should == dtl.transfer_requested_at.to_time.utc.to_s + trn_data.css('acDate').text.should == dtl.wait_until.to_time.utc.to_s + trn_data.css('acID').text.should == '123' + trn_data.css('exDate').text.should == domain.valid_to.to_time.utc.to_s + + domain.registrar.should == registrar2 + + # should show up in other registrar's poll + + response = login_as :registrar2 do + epp_plain_request(epp_xml.session.poll, :xml) + end + + response[:msg].should == 'Command completed successfully; ack to dequeue' + msg_q = response[:parsed].css('msgQ') + msg_q.css('qDate').text.should_not be_blank + msg_q.css('msg').text.should == 'Transfer requested.' + msg_q.first['id'].should_not be_blank + msg_q.first['count'].should == '1' + + xml = epp_xml.session.poll(poll: { + value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] } + }) + + response = login_as :registrar2 do + epp_plain_request(xml, :xml) + end + + response[:msg].should == 'Command completed successfully' + msg_q = response[:parsed].css('msgQ') + msg_q.first['id'].should_not be_blank + msg_q.first['count'].should == '0' + + create_settings + end + + it 'creates a domain transfer with legal document' do + Setting.transfer_wait_time = 1 + domain.legal_documents.count.should == 0 + pw = domain.auth_info + xml = domain_transfer_xml({ + name: { value: domain.name }, + authInfo: { pw: { value: pw } } + }, 'query', { + _anonymus: [ + legalDocument: { + value: 'JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0Zp==', + attrs: { type: 'pdf' } + } + ] + }) + + login_as :registrar2 do + response = epp_plain_request(xml, :xml) + response[:result_code].should == '1000' + domain.legal_documents.count.should == 1 + + log = ApiLog::EppLog.last + + log.request_command.should == 'transfer' + log.request_object.should == 'domain' + log.request_successful.should == true + log.api_user_name.should == 'registrar2' + log.api_user_registrar.should == 'registrar2' + log.request.should_not be_blank + log.response.should_not be_blank + end + + response = login_as :registrar2 do + epp_plain_request(xml, :xml) + end + + response[:result_code].should == '1000' + domain.legal_documents.count.should == 1 # does not add another legal documen + + create_settings + end + + it 'approves the transfer request' do + domain.domain_transfers.create({ + status: DomainTransfer::PENDING, + transfer_requested_at: Time.zone.now, + transfer_to: registrar2, + transfer_from: registrar1 + }) + + xml = domain_transfer_xml({ + name: { value: domain.name }, + authInfo: { pw: { value: domain.auth_info } } + }, 'approve') + + response = epp_plain_request(xml, :xml) + + domain.reload + dtl = domain.domain_transfers.last + + trn_data = response[:parsed].css('trnData') + + trn_data.css('name').text.should == domain.name + trn_data.css('trStatus').text.should == 'clientApproved' + trn_data.css('reID').text.should == '123' + trn_data.css('reDate').text.should == dtl.transfer_requested_at.to_time.utc.to_s + trn_data.css('acID').text.should == '12345678' + trn_data.css('exDate').text.should == domain.valid_to.to_time.utc.to_s + end + + it 'rejects a domain transfer' do + domain.domain_transfers.create({ + status: DomainTransfer::PENDING, + transfer_requested_at: Time.zone.now, + transfer_to: registrar2, + transfer_from: registrar1 + }) + + pw = domain.auth_info + xml = domain_transfer_xml({ + name: { value: domain.name }, + authInfo: { pw: { value: pw } } + }, 'reject', { + _anonymus: [ + legalDocument: { + value: 'JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0Zp==', + attrs: { type: 'pdf' } + } + ] + }) + + response = login_as :registrar2 do + epp_plain_request(xml, :xml) + end + + response[:msg].should == 'Transfer can be rejected only by current registrar' + response[:result_code].should == '2304' + domain.legal_documents.count.should == 0 + + response = epp_plain_request(xml, :xml) + response[:result_code].should == '1000' + domain.pending_transfer.should be_nil + domain.legal_documents.count.should == 1 + end + + it 'prohibits wrong registrar from approving transfer' do + domain.domain_transfers.create({ + status: DomainTransfer::PENDING, + transfer_requested_at: Time.zone.now, + transfer_to: registrar2, + transfer_from: registrar1 + }) + + xml = domain_transfer_xml({ + name: { value: domain.name }, + authInfo: { pw: { value: domain.auth_info } } + }, 'approve') + + response = login_as :registrar2 do + epp_plain_request(xml, :xml) + end + + response[:result_code].should == '2304' + response[:msg].should == 'Transfer can be approved only by current domain registrar' + end + + it 'does not transfer with invalid pw' do + xml = domain_transfer_xml({ + name: { value: domain.name }, + authInfo: { pw: { value: 'test' } } + }) + response = epp_plain_request(xml, :xml) + response[:result_code].should == '2201' + response[:msg].should == 'Authorization error' + end + + it 'ignores transfer when owner registrar requests transfer' do + pw = domain.auth_info + xml = domain_transfer_xml({ + name: { value: domain.name }, + authInfo: { pw: { value: pw } } + }) + + response = epp_plain_request(xml, :xml) + + response[:result_code].should == '2002' + response[:msg].should == 'Domain already belongs to the querying registrar' + end + + it 'returns an error for incorrect op attribute' do + response = epp_plain_request(domain_transfer_xml({}, 'bla'), :xml) + response[:result_code].should == '2306' + response[:msg].should == 'Attribute op is invalid' + end + + it 'creates new pw after successful transfer' do + pw = domain.auth_info + xml = domain_transfer_xml({ + name: { value: domain.name }, + authInfo: { pw: { value: pw } } + }) + + login_as :registrar2 do + epp_plain_request(xml, :xml) # transfer domain + response = epp_plain_request(xml, :xml) # attempt second transfer + response[:result_code].should == '2201' + response[:msg].should == 'Authorization error' end end - context 'with juridical persion as an owner' do - before(:each) do - Fabricate(:contact, code: 'jd1234', ident_type: 'ico') - Fabricate(:contact, code: 'sh8013') - Fabricate(:contact, code: 'sh801333') - end + ### UPDATE ### + it 'updates a domain' do + existing_pw = Domain.last.auth_info - it 'creates a domain with contacts' do - xml = domain_create_xml({ - _anonymus: [ - { contact: { value: 'sh8013', attrs: { type: 'admin' } } } - ] - }) + xml_params = { + name: { value: domain.name }, + chg: [ + registrant: { value: 'citizen_1234' } + ] + } - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') - expect(response[:clTRID]).to eq('ABC-12345') + response = epp_plain_request(domain_update_xml(xml_params, {}, { + _anonymus: [ + legalDocument: { + value: 'JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0Zp==', + attrs: { type: 'pdf' } + } + ] + }), :xml) - expect(Domain.first.tech_contacts.count).to eq 1 - expect(Domain.first.admin_contacts.count).to eq 1 + response[:results][0][:result_code].should == '1000' - tech_contact = Domain.first.tech_contacts.first - expect(tech_contact.code).to eq('jd1234') - end + d = Domain.last - it 'does not create a domain without admin contact' do - xml = domain_create_xml({ - _anonymus: [ - { contact: { value: 'sh8013', attrs: { type: 'tech' } } } - ] - }) - - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2004') - expect(response[:msg]).to eq('Admin contacts count must be between 1-10') - expect(response[:clTRID]).to eq('ABC-12345') - - expect(Domain.count).to eq 0 - expect(DomainContact.count).to eq 0 - end - - it 'cannot assign juridical person as admin contact' do - xml = domain_create_xml({ - _anonymus: [ - { contact: { value: 'jd1234', attrs: { type: 'admin' } } } - ] - }) - - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2306') - expect(response[:msg]).to eq('Admin contact can be only citizen') - end + d.owner_contact_code.should == 'citizen_1234' + d.auth_info.should == existing_pw end - context 'with valid domain' do - before(:each) { Fabricate(:domain, name: 'example.ee', registrar: zone, dnskeys: []) } - let(:domain) { Domain.first } - - ### TRANSFER ### - it 'transfers a domain' do - pw = domain.auth_info - xml = domain_transfer_xml({ authInfo: { pw: { value: pw } } }) - response = epp_request(xml, :xml, :elkdata) - - domain.reload - dtl = domain.domain_transfers.last - - trn_data = response[:parsed].css('trnData') - expect(trn_data.css('name').text).to eq('example.ee') - expect(trn_data.css('trStatus').text).to eq('serverApproved') - expect(trn_data.css('reID').text).to eq('123') - expect(trn_data.css('reDate').text).to eq(dtl.transfer_requested_at.to_time.utc.to_s) - expect(trn_data.css('acID').text).to eq('12345678') - expect(trn_data.css('acDate').text).to eq(dtl.transferred_at.to_time.utc.to_s) - expect(trn_data.css('exDate').text).to eq(domain.valid_to.to_time.utc.to_s) - - expect(domain.registrar).to eq(elkdata) - - Setting.transfer_wait_time = 1 - - domain.reload - pw = domain.auth_info - xml = domain_transfer_xml({ authInfo: { pw: { value: pw } } }) # request with new password - - response = epp_request(xml, :xml, :zone) - trn_data = response[:parsed].css('trnData') - - domain.reload - dtl = domain.domain_transfers.last - - expect(domain.domain_transfers.count).to eq(2) - - expect(trn_data.css('name').text).to eq('example.ee') - expect(trn_data.css('trStatus').text).to eq('pending') - expect(trn_data.css('reID').text).to eq('12345678') - expect(trn_data.css('reDate').text).to eq(dtl.transfer_requested_at.to_time.utc.to_s) - expect(trn_data.css('acDate').text).to eq(dtl.wait_until.to_time.utc.to_s) - expect(trn_data.css('acID').text).to eq('123') - expect(trn_data.css('exDate').text).to eq(domain.valid_to.to_time.utc.to_s) - - expect(domain.registrar).to eq(elkdata) - - # should return same data if pending already - response = epp_request(xml, :xml, :zone) - trn_data = response[:parsed].css('trnData') - - expect(domain.domain_transfers.count).to eq(2) - expect(trn_data.css('name').text).to eq('example.ee') - expect(trn_data.css('trStatus').text).to eq('pending') - expect(trn_data.css('reID').text).to eq('12345678') - expect(trn_data.css('reDate').text).to eq(dtl.transfer_requested_at.to_time.utc.to_s) - expect(trn_data.css('acDate').text).to eq(dtl.wait_until.to_time.utc.to_s) - expect(trn_data.css('acID').text).to eq('123') - expect(trn_data.css('exDate').text).to eq(domain.valid_to.to_time.utc.to_s) - - expect(domain.registrar).to eq(elkdata) - - # should show up in other registrar's poll - - response = epp_request(epp_xml.session.poll, :xml, :elkdata) - expect(response[:msg]).to eq('Command completed successfully; ack to dequeue') - msg_q = response[:parsed].css('msgQ') - expect(msg_q.css('qDate').text).to_not be_blank - expect(msg_q.css('msg').text).to eq('Transfer requested.') - expect(msg_q.first['id']).to_not be_blank - expect(msg_q.first['count']).to eq('1') - - xml = epp_xml.session.poll(poll: { - value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] } - }) - - response = epp_request(xml, :xml, :elkdata) - expect(response[:msg]).to eq('Command completed successfully') - msg_q = response[:parsed].css('msgQ') - expect(msg_q.first['id']).to_not be_blank - expect(msg_q.first['count']).to eq('0') - end - - it 'creates a domain transfer with legal document' do - Setting.transfer_wait_time = 1 - expect(domain.legal_documents.count).to eq(0) - pw = domain.auth_info - xml = domain_transfer_xml({ authInfo: { pw: { value: pw } } }, 'query', { - _anonymus: [ - legalDocument: { - value: 'JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0Zp==', - attrs: { type: 'pdf' } - } - ] - }) - - response = epp_request(xml, :xml, :elkdata) - expect(response[:result_code]).to eq('1000') - expect(domain.legal_documents.count).to eq(1) - - log = ApiLog::EppLog.all - - expect(log.length).to eq(4) - expect(log[0].request_command).to eq('hello') - expect(log[0].request_successful).to eq(true) - - expect(log[1].request_command).to eq('login') - expect(log[1].request_successful).to eq(true) - expect(log[1].api_user_name).to eq('elkdata') - expect(log[1].api_user_registrar).to eq('Elkdata') - - expect(log[2].request_command).to eq('transfer') - expect(log[2].request_object).to eq('domain') - expect(log[2].request_successful).to eq(true) - expect(log[2].api_user_name).to eq('elkdata') - expect(log[2].api_user_registrar).to eq('Elkdata') - expect(log[2].request).not_to be_blank - expect(log[2].response).not_to be_blank - - expect(log[3].request_command).to eq('logout') - expect(log[3].request_successful).to eq(true) - expect(log[3].api_user_name).to eq('elkdata') - expect(log[3].api_user_registrar).to eq('Elkdata') - - response = epp_request(xml, :xml, :elkdata) - expect(response[:result_code]).to eq('1000') - expect(domain.legal_documents.count).to eq(1) # does not add another legal document - end - - it 'approves the transfer request' do - domain.domain_transfers.create({ - status: DomainTransfer::PENDING, - transfer_requested_at: Time.zone.now, - transfer_to: elkdata, - transfer_from: zone - }) - - xml = domain_transfer_xml({ authInfo: { pw: { value: domain.auth_info } } }, 'approve') - response = epp_request(xml, :xml, :zone) - domain.reload - dtl = domain.domain_transfers.last - - trn_data = response[:parsed].css('trnData') - - expect(trn_data.css('name').text).to eq('example.ee') - expect(trn_data.css('trStatus').text).to eq('clientApproved') - expect(trn_data.css('reID').text).to eq('123') - expect(trn_data.css('reDate').text).to eq(dtl.transfer_requested_at.to_time.utc.to_s) - expect(trn_data.css('acID').text).to eq('12345678') - expect(trn_data.css('exDate').text).to eq(domain.valid_to.to_time.utc.to_s) - end - - it 'rejects a domain transfer' do - domain.domain_transfers.create({ - status: DomainTransfer::PENDING, - transfer_requested_at: Time.zone.now, - transfer_to: elkdata, - transfer_from: zone - }) - - pw = domain.auth_info - xml = domain_transfer_xml({ authInfo: { pw: { value: pw } } }, 'reject', { - _anonymus: [ - legalDocument: { - value: 'JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0Zp==', - attrs: { type: 'pdf' } - } - ] - }) - - response = epp_request(xml, :xml, :elkdata) - expect(response[:result_code]).to eq('2304') - expect(response[:msg]).to eq('Transfer can be rejected only by current registrar') - expect(domain.legal_documents.count).to eq(0) - - response = epp_request(xml, :xml, :zone) - expect(response[:result_code]).to eq('1000') - expect(domain.pending_transfer).to be_nil - expect(domain.legal_documents.count).to eq(1) - end - - it 'prohibits wrong registrar from approving transfer' do - domain.domain_transfers.create({ - status: DomainTransfer::PENDING, - transfer_requested_at: Time.zone.now, - transfer_to: elkdata, - transfer_from: zone - }) - - xml = domain_transfer_xml({ authInfo: { pw: { value: domain.auth_info } } }, 'approve') - response = epp_request(xml, :xml, :elkdata) - expect(response[:result_code]).to eq('2304') - expect(response[:msg]).to eq('Transfer can be approved only by current domain registrar') - end - - it 'does not transfer with invalid pw' do - xml = domain_transfer_xml({ authInfo: { pw: { value: 'test' } } }) - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2201') - expect(response[:msg]).to eq('Authorization error') - end - - it 'ignores transfer when owner registrar requests transfer' do - pw = domain.auth_info - xml = domain_transfer_xml({ authInfo: { pw: { value: pw } } }) - response = epp_request(xml, :xml, :zone) - - expect(response[:result_code]).to eq('2002') - expect(response[:msg]).to eq('Domain already belongs to the querying registrar') - end - - it 'returns an error for incorrect op attribute' do - response = epp_request(domain_transfer_xml({}, 'bla'), :xml, :zone) - expect(response[:result_code]).to eq('2306') - expect(response[:msg]).to eq('Attribute op is invalid') - end - - it 'creates new pw after successful transfer' do - pw = domain.auth_info - xml = domain_transfer_xml(pw: pw) - epp_request(xml, :xml, :elkdata) # transfer domain - response = epp_request(xml, :xml, :elkdata) # attempt second transfer - expect(response[:result_code]).to eq('2201') - expect(response[:msg]).to eq('Authorization error') - end - - ### UPDATE ### - it 'updates a domain' do - Fabricate(:contact, code: 'mak21') - existing_pw = Domain.first.auth_info - - xml_params = { - chg: [ - registrant: { value: 'mak21' } - ] - } - - response = epp_request(domain_update_xml(xml_params, {}, { - _anonymus: [ - legalDocument: { - value: 'JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0Zp==', - attrs: { type: 'pdf' } - } - ] - }), :xml) - - expect(response[:results][0][:result_code]).to eq('1000') - - d = Domain.last - - expect(d.owner_contact_code).to eq('mak21') - expect(d.auth_info).to eq(existing_pw) - end - - it 'updates domain and adds objects' do - xml = domain_update_xml({ - add: [ - { - ns: [ - { - hostAttr: [ - { hostName: { value: 'ns1.example.com' } } - ] - }, - { - hostAttr: [ - { hostName: { value: 'ns2.example.com' } } - ] - } - ] - }, - _anonymus: [ - { contact: { value: 'mak21', attrs: { type: 'tech' } } }, - { status: { value: 'Payment overdue.', attrs: { s: 'clientHold', lang: 'en' } } }, - { status: { value: '', attrs: { s: 'clientUpdateProhibited' } } } - ] - ] - }, { - add: [ - { keyData: { - flags: { value: '0' }, - protocol: { value: '3' }, - alg: { value: '5' }, - pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } - } - }, - { - keyData: { - flags: { value: '256' }, - protocol: { value: '3' }, - alg: { value: '254' }, - pubKey: { value: '841936717ae427ace63c28d04918569a841936717ae427ace63c28d0' } - } - } - ] - }) - - response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2303') - expect(response[:results][0][:msg]).to eq('Contact was not found') - - Fabricate(:contact, code: 'mak21') - - response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('1000') - - d = Domain.first - - new_ns_count = d.nameservers.where(hostname: ['ns1.example.com', 'ns2.example.com']).count - expect(new_ns_count).to eq(2) - - new_contact = d.tech_contacts.find_by(code: 'mak21') - expect(new_contact).to be_truthy - - expect(d.domain_statuses.count).to eq(2) - expect(d.domain_statuses.first.description).to eq('Payment overdue.') - expect(d.domain_statuses.first.value).to eq('clientHold') - - expect(d.domain_statuses.last.value).to eq('clientUpdateProhibited') - expect(d.dnskeys.count).to eq(2) - - response = epp_request(xml, :xml) - - expect(response[:results][0][:result_code]).to eq('2302') - expect(response[:results][0][:msg]).to eq('Nameserver already exists on this domain') - expect(response[:results][0][:value]).to eq('ns1.example.com') - - expect(response[:results][1][:result_code]).to eq('2302') - expect(response[:results][1][:msg]).to eq('Nameserver already exists on this domain') - expect(response[:results][1][:value]).to eq('ns2.example.com') - - expect(response[:results][2][:result_code]).to eq('2302') - expect(response[:results][2][:msg]).to eq('Contact already exists on this domain') - expect(response[:results][2][:value]).to eq('mak21') - - expect(response[:results][3][:msg]).to eq('Status already exists on this domain') - expect(response[:results][3][:value]).to eq('clientHold') - - expect(response[:results][4][:msg]).to eq('Status already exists on this domain') - expect(response[:results][4][:value]).to eq('clientUpdateProhibited') - - expect(response[:results][5][:msg]).to eq('Public key already exists') - expect(response[:results][5][:value]).to eq('700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f') - - expect(response[:results][6][:msg]).to eq('Public key already exists') - expect(response[:results][6][:value]).to eq('841936717ae427ace63c28d04918569a841936717ae427ace63c28d0') - - expect(d.domain_statuses.count).to eq(2) - end - - it 'updates a domain and removes objects' do - Fabricate(:contact, code: 'mak21') - - xml = domain_update_xml({ - add: [ - { - ns: [ - { - hostAttr: [ - { hostName: { value: 'ns1.example.com' } } - ] - }, - { - hostAttr: [ - { hostName: { value: 'ns2.example.com' } } - ] - } - ] - }, - _anonymus: [ - { contact: { value: 'mak21', attrs: { type: 'tech' } } }, - { status: { value: 'Payment overdue.', attrs: { s: 'clientHold', lang: 'en' } } }, - { status: { value: '', attrs: { s: 'clientUpdateProhibited' } } } - ] - ] - }, { - add: [ - { keyData: { - flags: { value: '0' }, - protocol: { value: '3' }, - alg: { value: '5' }, - pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } - } - }, - { - keyData: { - flags: { value: '256' }, - protocol: { value: '3' }, - alg: { value: '254' }, - pubKey: { value: '841936717ae427ace63c28d04918569a841936717ae427ace63c28d0' } - } - } - ] - }) - - epp_request(xml, :xml) - d = Domain.last - expect(d.dnskeys.count).to eq(2) - - xml = domain_update_xml({ - rem: [ - { - ns: [ - { - hostAttr: [ - { hostName: { value: 'ns1.example.com' } } - ] - } - ] - }, - _anonymus: [ - { contact: { value: 'mak21', attrs: { type: 'tech' } } }, - { status: { value: '', attrs: { s: 'clientHold' } } } - ] - ] - }, { - rem: [ - { keyData: { - pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } - } - } - ] - }) - - epp_request(xml, :xml) - - expect(d.dnskeys.count).to eq(1) - - expect(d.domain_statuses.count).to eq(1) - expect(d.domain_statuses.first.value).to eq('clientUpdateProhibited') - - rem_ns = d.nameservers.find_by(hostname: 'ns1.example.com') - expect(rem_ns).to be_falsey - - rem_cnt = d.tech_contacts.find_by(code: 'mak21') - expect(rem_cnt).to be_falsey - - response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2303') - expect(response[:results][0][:msg]).to eq('Contact was not found') - expect(response[:results][0][:value]).to eq('mak21') - - expect(response[:results][1][:result_code]).to eq('2303') - expect(response[:results][1][:msg]).to eq('Nameserver was not found') - expect(response[:results][1][:value]).to eq('ns1.example.com') - - expect(response[:results][2][:result_code]).to eq('2303') - expect(response[:results][2][:msg]).to eq('Status was not found') - expect(response[:results][2][:value]).to eq('clientHold') - end - - it 'does not remove server statuses' do - d = Domain.last - d.domain_statuses.create(value: DomainStatus::SERVER_HOLD) - - xml = domain_update_xml({ - rem: [ - _anonymus: [ - { status: { value: '', attrs: { s: 'serverHold' } } } - ] - ] - }) - - response = epp_request(xml, :xml) - - expect(response[:results][0][:result_code]).to eq('2303') - expect(response[:results][0][:msg]).to eq('Status was not found') - expect(response[:results][0][:value]).to eq('serverHold') - end - - it 'does not add duplicate objects to domain' do - d = Domain.first - c = d.admin_contacts.first - n = d.nameservers.first - - xml = domain_update_xml({ - add: { + it 'updates domain and adds objects' do + xml = domain_update_xml({ + name: { value: domain.name }, + add: [ + { ns: [ { hostAttr: [ - { hostName: { value: n.hostname } } + { hostName: { value: 'ns1.example.com' } } + ] + }, + { + hostAttr: [ + { hostName: { value: 'ns2.example.com' } } ] } - ], - _anonymus: [ - { contact: { value: c.code, attrs: { type: 'admin' } } } ] + }, + _anonymus: [ + { contact: { value: 'mak21', attrs: { type: 'tech' } } }, + { status: { value: 'Payment overdue.', attrs: { s: 'clientHold', lang: 'en' } } }, + { status: { value: '', attrs: { s: 'clientUpdateProhibited' } } } + ] + ] + }, { + add: [ + { keyData: { + flags: { value: '0' }, + protocol: { value: '3' }, + alg: { value: '5' }, + pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } + } + }, + { + keyData: { + flags: { value: '256' }, + protocol: { value: '3' }, + alg: { value: '254' }, + pubKey: { value: '841936717ae427ace63c28d04918569a841936717ae427ace63c28d0' } + } } - }) + ] + }) - epp_request(xml, :xml) - response = epp_request(xml, :xml) + response = epp_plain_request(xml, :xml) + response[:results][0][:result_code].should == '2303' + response[:results][0][:msg].should == 'Contact was not found' - expect(response[:results][0][:result_code]).to eq('2302') - expect(response[:results][0][:msg]).to eq('Nameserver already exists on this domain') - expect(response[:results][0][:value]).to eq(n.hostname) + Fabricate(:contact, code: 'mak21') - expect(response[:results][1][:result_code]).to eq('2302') - expect(response[:results][1][:msg]).to eq('Contact already exists on this domain') - expect(response[:results][1][:value]).to eq(c.code) - end + response = epp_plain_request(xml, :xml) + response[:results][0][:result_code].should == '1000' - it 'cannot change registrant without legal document' do - Fabricate(:contact, code: 'mak21') + d = Domain.last - xml_params = { - chg: [ - registrant: { value: 'mak21' } + new_ns_count = d.nameservers.where(hostname: ['ns1.example.com', 'ns2.example.com']).count + new_ns_count.should == 2 + + new_contact = d.tech_contacts.find_by(code: 'mak21') + new_contact.should be_truthy + + d.domain_statuses.count.should == 2 + d.domain_statuses.first.description.should == 'Payment overdue.' + d.domain_statuses.first.value.should == 'clientHold' + + d.domain_statuses.last.value.should == 'clientUpdateProhibited' + d.dnskeys.count.should == 2 + + response = epp_plain_request(xml, :xml) + + response[:results][0][:result_code].should == '2302' + response[:results][0][:msg].should == 'Nameserver already exists on this domain' + response[:results][0][:value].should == 'ns1.example.com' + + response[:results][1][:result_code].should == '2302' + response[:results][1][:msg].should == 'Nameserver already exists on this domain' + response[:results][1][:value].should == 'ns2.example.com' + + response[:results][2][:result_code].should == '2302' + response[:results][2][:msg].should == 'Contact already exists on this domain' + response[:results][2][:value].should == 'mak21' + + response[:results][3][:msg].should == 'Status already exists on this domain' + response[:results][3][:value].should == 'clientHold' + + response[:results][4][:msg].should == 'Status already exists on this domain' + response[:results][4][:value].should == 'clientUpdateProhibited' + + response[:results][5][:msg].should == 'Public key already exists' + response[:results][5][:value].should == '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' + + response[:results][6][:msg].should == 'Public key already exists' + response[:results][6][:value].should == '841936717ae427ace63c28d04918569a841936717ae427ace63c28d0' + + d.domain_statuses.count.should == 2 + end + + it 'updates a domain and removes objects' do + xml = domain_update_xml({ + name: { value: domain.name }, + add: [ + { + ns: [ + { + hostAttr: [ + { hostName: { value: 'ns1.example.com' } } + ] + }, + { + hostAttr: [ + { hostName: { value: 'ns2.example.com' } } + ] + } + ] + }, + _anonymus: [ + { contact: { value: 'citizen_1234', attrs: { type: 'tech' } } }, + { status: { value: 'Payment overdue.', attrs: { s: 'clientHold', lang: 'en' } } }, + { status: { value: '', attrs: { s: 'clientUpdateProhibited' } } } + ] + ] + }, { + add: [ + { keyData: { + flags: { value: '0' }, + protocol: { value: '3' }, + alg: { value: '5' }, + pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } + } + }, + { + keyData: { + flags: { value: '256' }, + protocol: { value: '3' }, + alg: { value: '254' }, + pubKey: { value: '841936717ae427ace63c28d04918569a841936717ae427ace63c28d0' } + } + } + ] + }) + + epp_plain_request(xml, :xml) + d = Domain.last + d.dnskeys.count.should == 2 + + xml = domain_update_xml({ + name: { value: domain.name }, + rem: [ + { + ns: [ + { + hostAttr: [ + { hostName: { value: 'ns1.example.com' } } + ] + } + ] + }, + _anonymus: [ + { contact: { value: 'citizen_1234', attrs: { type: 'tech' } } }, + { status: { value: '', attrs: { s: 'clientHold' } } } + ] + ] + }, { + rem: [ + { keyData: { + pubKey: { value: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' } + } + } + ] + }) + + epp_plain_request(xml, :xml) + + d.dnskeys.count.should == 1 + + d.domain_statuses.count.should == 1 + d.domain_statuses.first.value.should == 'clientUpdateProhibited' + + rem_ns = d.nameservers.find_by(hostname: 'ns1.example.com') + rem_ns.should be_falsey + + rem_cnt = d.tech_contacts.find_by(code: 'citizen_1234') + rem_cnt.should be_falsey + + response = epp_plain_request(xml, :xml) + response[:results][0][:result_code].should == '2303' + response[:results][0][:msg].should == 'Contact was not found' + response[:results][0][:value].should == 'citizen_1234' + + response[:results][1][:result_code].should == '2303' + response[:results][1][:msg].should == 'Nameserver was not found' + response[:results][1][:value].should == 'ns1.example.com' + + response[:results][2][:result_code].should == '2303' + response[:results][2][:msg].should == 'Status was not found' + response[:results][2][:value].should == 'clientHold' + end + + it 'does not remove server statuses' do + d = Domain.last + d.domain_statuses.create(value: DomainStatus::SERVER_HOLD) + + xml = domain_update_xml({ + name: { value: domain.name }, + rem: [ + _anonymus: [ + { status: { value: '', attrs: { s: 'serverHold' } } } + ] + ] + }) + + response = epp_plain_request(xml, :xml) + + response[:results][0][:result_code].should == '2303' + response[:results][0][:msg].should == 'Status was not found' + response[:results][0][:value].should == 'serverHold' + end + + it 'does not add duplicate objects to domain' do + d = Domain.last + c = d.admin_contacts.first + n = d.nameservers.first + + xml = domain_update_xml({ + name: { value: domain.name }, + add: { + ns: [ + { + hostAttr: [ + { hostName: { value: n.hostname } } + ] + } + ], + _anonymus: [ + { contact: { value: c.code, attrs: { type: 'admin' } } } ] } + }) - response = epp_request(domain_update_xml(xml_params), :xml) - expect(response[:results][0][:msg]).to eq('Required parameter missing: extension > extdata > legalDocument') - expect(response[:results][0][:result_code]).to eq('2003') + epp_plain_request(xml, :xml) + response = epp_plain_request(xml, :xml) + + response[:results][0][:result_code].should == '2302' + response[:results][0][:msg].should == 'Nameserver already exists on this domain' + response[:results][0][:value].should == n.hostname + + response[:results][1][:result_code].should == '2302' + response[:results][1][:msg].should == 'Contact already exists on this domain' + response[:results][1][:value].should == c.code + end + + it 'cannot change registrant without legal document' do + xml_params = { + name: { value: domain.name }, + chg: [ + registrant: { value: 'citizen_1234' } + ] + } + + response = epp_plain_request(domain_update_xml(xml_params), :xml) + response[:results][0][:msg].should == 'Required parameter missing: extension > extdata > legalDocument' + response[:results][0][:result_code].should == '2003' + end + + it 'does not assign invalid status to domain' do + xml = domain_update_xml({ + name: { value: domain.name }, + add: [ + status: { value: '', attrs: { s: 'invalidStatus' } } + ] + }) + + response = epp_plain_request(xml, :xml) + response[:results][0][:result_code].should == '2303' + response[:results][0][:msg].should == 'Status was not found' + response[:results][0][:value].should == 'invalidStatus' + end + + ### RENEW ### + it 'renews a domain' do + exp_date = (Date.today + 1.year) + xml = epp_xml.domain.renew( + name: { value: domain.name }, + curExpDate: { value: exp_date.to_s }, + period: { value: '1', attrs: { unit: 'y' } } + ) + + response = epp_plain_request(xml, :xml) + ex_date = response[:parsed].css('renData exDate').text + name = response[:parsed].css('renData name').text + ex_date.should == "#{(exp_date + 1.year)} 00:00:00 UTC" + name.should == domain.name + end + + it 'returns an error when given and current exp dates do not match' do + xml = epp_xml.domain.renew( + name: { value: domain.name }, + curExpDate: { value: '2200-08-07' }, + period: { value: '1', attrs: { unit: 'y' } } + ) + + response = epp_plain_request(xml, :xml) + response[:results][0][:result_code].should == '2306' + response[:results][0][:msg].should == 'Given and current expire dates do not match' + end + + it 'returns an error when period is invalid' do + exp_date = (Date.today + 1.year) + + xml = epp_xml.domain.renew( + name: { value: domain.name }, + curExpDate: { value: exp_date.to_s }, + period: { value: '4', attrs: { unit: 'y' } } + ) + + response = epp_plain_request(xml, :xml) + response[:results][0][:result_code].should == '2004' + response[:results][0][:msg].should == 'Period must add up to 1, 2 or 3 years' + response[:results][0][:value].should == '4' + end + + ### INFO ### + it 'returns domain info' do + domain.domain_statuses.build(value: DomainStatus::CLIENT_HOLD, description: 'Payment overdue.') + domain.nameservers.build(hostname: 'ns1.example.com', ipv4: '192.168.1.1', ipv6: '1080:0:0:0:8:800:200C:417A') + + domain.dnskeys.build( + ds_key_tag: '123', + ds_alg: 3, + ds_digest_type: 1, + ds_digest: 'abc', + flags: 257, + protocol: 3, + alg: 3, + public_key: 'AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8' + ) + + domain.dnskeys.build( + ds_key_tag: '123', + ds_alg: 3, + ds_digest_type: 1, + ds_digest: 'abc', + flags: 0, + protocol: 3, + alg: 5, + public_key: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' + ) + + domain.save + + xml = domain_info_xml(name: { value: domain.name }) + + response = epp_plain_request(xml, :xml) + response[:results][0][:result_code].should == '1000' + response[:results][0][:msg].should == 'Command completed successfully' + + inf_data = response[:parsed].css('resData infData') + inf_data.css('name').text.should == domain.name + inf_data.css('status').text.should == 'Payment overdue.' + inf_data.css('status').first[:s].should == 'clientHold' + inf_data.css('registrant').text.should == domain.owner_contact_code + + admin_contacts_from_request = inf_data.css('contact[type="admin"]').map(&:text) + admin_contacts_existing = domain.admin_contacts.pluck(:code) + + admin_contacts_from_request.should == admin_contacts_existing + + hosts_from_request = inf_data.css('hostName').map(&:text) + hosts_existing = domain.nameservers.pluck(:hostname) + + hosts_from_request.should == hosts_existing + + ns1 = inf_data.css('hostAttr').last + + ns1.css('hostName').last.text.should == 'ns1.example.com' + ns1.css('hostAddr').first.text.should == '192.168.1.1' + ns1.css('hostAddr').last.text.should == '1080:0:0:0:8:800:200C:417A' + inf_data.css('crDate').text.should == domain.created_at.to_time.utc.to_s + inf_data.css('exDate').text.should == domain.valid_to.to_time.utc.to_s + inf_data.css('pw').text.should == domain.auth_info + + ds_data_1 = response[:parsed].css('dsData')[0] + + ds_data_1.css('keyTag').first.text.should == '123' + ds_data_1.css('alg').first.text.should == '3' + ds_data_1.css('digestType').first.text.should == '1' + ds_data_1.css('digest').first.text.should == 'abc' + + dnskey_1 = ds_data_1.css('keyData')[0] + dnskey_1.css('flags').first.text.should == '257' + dnskey_1.css('protocol').first.text.should == '3' + dnskey_1.css('alg').first.text.should == '3' + dnskey_1.css('pubKey').first.text.should == 'AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8' + + ds_data_2 = response[:parsed].css('dsData')[1] + + dnskey_2 = ds_data_2.css('keyData')[0] + dnskey_2.css('flags').first.text.should == '0' + dnskey_2.css('protocol').first.text.should == '3' + dnskey_2.css('alg').first.text.should == '5' + dnskey_2.css('pubKey').first.text.should == '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' + + domain.touch + + response = epp_plain_request(domain_info_xml(name: { value: domain.name }), :xml) + inf_data = response[:parsed].css('resData infData') + + inf_data.css('upDate').text.should == domain.updated_at.to_time.utc.to_s + end + + it 'returns error when domain can not be found' do + response = epp_plain_request(domain_info_xml(name: { value: 'test.ee' }), :xml) + response[:results][0][:result_code].should == '2303' + response[:results][0][:msg].should == 'Domain not found' + end + + it 'sets ok status by default' do + response = epp_plain_request(domain_info_xml(name: { value: domain.name }), :xml) + inf_data = response[:parsed].css('resData infData') + inf_data.css('status').first[:s].should == 'ok' + end + + it 'can not see other registrar domains' do + login_as :registrar2 do + response = epp_plain_request(domain_info_xml(name: { value: domain.name }), :xml) + response[:result_code].should == '2302' + response[:msg].should == 'Domain exists but belongs to other registrar' end + end - it 'does not assign invalid status to domain' do - xml = domain_update_xml({ - add: [ - status: { value: '', attrs: { s: 'invalidStatus' } } - ] - }) + ### DELETE ### + it 'deletes domain' do + response = epp_plain_request(epp_xml.domain.delete({ + name: { value: domain.name } + }, { + _anonymus: [ + legalDocument: { + value: 'JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0Zp==', + attrs: { type: 'pdf' } + } + ] + }), :xml) - response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2303') - expect(response[:results][0][:msg]).to eq('Status was not found') - expect(response[:results][0][:value]).to eq('invalidStatus') - end + response[:result_code].should == '1000' - ### RENEW ### - it 'renews a domain' do - exp_date = (Date.today + 1.year) - xml = epp_xml.domain.renew( - name: { value: 'example.ee' }, - curExpDate: { value: exp_date.to_s }, - period: { value: '1', attrs: { unit: 'y' } } - ) + Domain.find_by(name: domain.name).should == nil + end - response = epp_request(xml, :xml) - ex_date = response[:parsed].css('renData exDate').text - name = response[:parsed].css('renData name').text - expect(ex_date).to eq("#{(exp_date + 1.year)} 00:00:00 UTC") - expect(name).to eq('example.ee') - end + it 'does not delete domain with specific status' do + domain.domain_statuses.create(value: DomainStatus::CLIENT_DELETE_PROHIBITED) - it 'returns an error when given and current exp dates do not match' do - xml = epp_xml.domain.renew( - name: { value: 'example.ee' }, - curExpDate: { value: '2016-08-07' }, - period: { value: '1', attrs: { unit: 'y' } } - ) + response = epp_plain_request(epp_xml.domain.delete({ + name: { value: domain.name } + }, { + _anonymus: [ + legalDocument: { + value: 'JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0Zp==', + attrs: { type: 'pdf' } + } + ] + }), :xml) - response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2306') - expect(response[:results][0][:msg]).to eq('Given and current expire dates do not match') - end + response[:result_code].should == '2304' + response[:msg].should == 'Domain status prohibits operation' + end - it 'returns an error when period is invalid' do - exp_date = (Date.today + 1.year) - - xml = epp_xml.domain.renew( - name: { value: 'example.ee' }, - curExpDate: { value: exp_date.to_s }, - period: { value: '4', attrs: { unit: 'y' } } - ) - - response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2004') - expect(response[:results][0][:msg]).to eq('Period must add up to 1, 2 or 3 years') - expect(response[:results][0][:value]).to eq('4') - end - - ### INFO ### - it 'returns domain info' do - d = Domain.first - d.domain_statuses.build(value: DomainStatus::CLIENT_HOLD, description: 'Payment overdue.') - d.nameservers.build(hostname: 'ns1.example.com', ipv4: '192.168.1.1', ipv6: '1080:0:0:0:8:800:200C:417A') - - d.dnskeys.build( - ds_key_tag: '123', - ds_alg: 3, - ds_digest_type: 1, - ds_digest: 'abc', - flags: 257, - protocol: 3, - alg: 3, - public_key: 'AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8' - ) - - d.dnskeys.build( - ds_key_tag: '123', - ds_alg: 3, - ds_digest_type: 1, - ds_digest: 'abc', - flags: 0, - protocol: 3, - alg: 5, - public_key: '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' - ) - - d.save - - xml = domain_info_xml(name: { value: 'Example.ee' }) - - response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('1000') - expect(response[:results][0][:msg]).to eq('Command completed successfully') - - inf_data = response[:parsed].css('resData infData') - expect(inf_data.css('name').text).to eq('example.ee') - expect(inf_data.css('status').text).to eq('Payment overdue.') - expect(inf_data.css('status').first[:s]).to eq('clientHold') - expect(inf_data.css('registrant').text).to eq(d.owner_contact_code) - - admin_contacts_from_request = inf_data.css('contact[type="admin"]').map(&:text) - admin_contacts_existing = d.admin_contacts.pluck(:code) - - expect(admin_contacts_from_request).to eq(admin_contacts_existing) - - hosts_from_request = inf_data.css('hostName').map(&:text) - hosts_existing = d.nameservers.pluck(:hostname) - - expect(hosts_from_request).to eq(hosts_existing) - - ns1 = inf_data.css('hostAttr').last - - expect(ns1.css('hostName').last.text).to eq('ns1.example.com') - expect(ns1.css('hostAddr').first.text).to eq('192.168.1.1') - expect(ns1.css('hostAddr').last.text).to eq('1080:0:0:0:8:800:200C:417A') - expect(inf_data.css('crDate').text).to eq(d.created_at.to_time.utc.to_s) - expect(inf_data.css('exDate').text).to eq(d.valid_to.to_time.utc.to_s) - expect(inf_data.css('pw').text).to eq(d.auth_info) - - ds_data_1 = response[:parsed].css('dsData')[0] - - expect(ds_data_1.css('keyTag').first.text).to eq('123') - expect(ds_data_1.css('alg').first.text).to eq('3') - expect(ds_data_1.css('digestType').first.text).to eq('1') - expect(ds_data_1.css('digest').first.text).to eq('abc') - - dnskey_1 = ds_data_1.css('keyData')[0] - expect(dnskey_1.css('flags').first.text).to eq('257') - expect(dnskey_1.css('protocol').first.text).to eq('3') - expect(dnskey_1.css('alg').first.text).to eq('3') - expect(dnskey_1.css('pubKey').first.text).to eq('AwEAAddt2AkLfYGKgiEZB5SmIF8EvrjxNMH6HtxWEA4RJ9Ao6LCWheg8') - - ds_data_2 = response[:parsed].css('dsData')[1] - - dnskey_2 = ds_data_2.css('keyData')[0] - expect(dnskey_2.css('flags').first.text).to eq('0') - expect(dnskey_2.css('protocol').first.text).to eq('3') - expect(dnskey_2.css('alg').first.text).to eq('5') - expect(dnskey_2.css('pubKey').first.text).to eq('700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f') - - d.touch - - response = epp_request(domain_info_xml, :xml) - inf_data = response[:parsed].css('resData infData') - - expect(inf_data.css('upDate').text).to eq(d.updated_at.to_time.utc.to_s) - end - - it 'returns error when domain can not be found' do - response = epp_request(domain_info_xml(name: { value: 'test.ee' }), :xml) - expect(response[:results][0][:result_code]).to eq('2303') - expect(response[:results][0][:msg]).to eq('Domain not found') - end - - it 'sets ok status by default' do - response = epp_request(domain_info_xml, :xml) - inf_data = response[:parsed].css('resData infData') - expect(inf_data.css('status').first[:s]).to eq('ok') - end - - it 'can not see other registrar domains' do - response = epp_request(domain_info_xml, :xml, :elkdata) - expect(response[:result_code]).to eq('2302') - expect(response[:msg]).to eq('Domain exists but belongs to other registrar') - end - - ### DELETE ### - it 'deletes domain' do - expect(DomainContact.count).to eq(2) - - response = epp_request(epp_xml.domain.delete({ - name: { value: 'example.ee' } - }, { - _anonymus: [ - legalDocument: { - value: 'JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0Zp==', - attrs: { type: 'pdf' } - } - ] - }), :xml) - - expect(response[:result_code]).to eq('1000') - - expect(Domain.first).to eq(nil) - expect(DomainContact.count).to eq(0) - end - - it 'does not delete domain with specific status' do - d = Domain.first - d.domain_statuses.create(value: DomainStatus::CLIENT_DELETE_PROHIBITED) - - response = epp_request(epp_xml.domain.delete({ - name: { value: 'example.ee' } - }, { - _anonymus: [ - legalDocument: { - value: 'JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0Zp==', - attrs: { type: 'pdf' } - } - ] - }), :xml) - - expect(response[:result_code]).to eq('2304') - expect(response[:msg]).to eq('Domain status prohibits operation') - end - - it 'does not delete domain without legal document' do - response = epp_request(epp_xml.domain.delete(name: { value: 'example.ee' }), :xml) - expect(response[:result_code]).to eq('2003') - expect(response[:msg]).to eq('Required parameter missing: extension > extdata > legalDocument') - end + it 'does not delete domain without legal document' do + response = epp_plain_request(epp_xml.domain.delete(name: { value: 'example.ee' }), :xml) + response[:result_code].should == '2003' + response[:msg].should == 'Required parameter missing: extension > extdata > legalDocument' end ### CHECK ### it 'checks a domain' do - response = epp_request(domain_check_xml, :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') + response = epp_plain_request(domain_check_xml({ + _anonymus: [ + { name: { value: 'one.ee' } } + ] + }), :xml) - domain = response[:parsed].css('resData chkData cd name').first - expect(domain.text).to eq('example.ee') - expect(domain[:avail]).to eq('1') + response[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' - Fabricate(:domain, name: 'example.ee', registrar: zone) + res_data = response[:parsed].css('resData chkData cd name').first + res_data.text.should == 'one.ee' + res_data[:avail].should == '1' - response = epp_request(domain_check_xml, :xml) - domain = response[:parsed].css('resData chkData cd').first - name = domain.css('name').first - reason = domain.css('reason').first + response = epp_plain_request(domain_check_xml({ + _anonymus: [ + { name: { value: domain.name } } + ] + }), :xml) + res_data = response[:parsed].css('resData chkData cd').first + name = res_data.css('name').first + reason = res_data.css('reason').first - expect(name.text).to eq('example.ee') - expect(name[:avail]).to eq('0') - expect(reason.text).to eq('in use') + name.text.should == domain.name + name[:avail].should == '0' + reason.text.should == 'in use' end it 'checks multiple domains' do @@ -1411,17 +1500,17 @@ describe 'EPP Domain', epp: true do ] }) - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') + response = epp_plain_request(xml, :xml) + response[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' - domain = response[:parsed].css('resData chkData cd name').first - expect(domain.text).to eq('one.ee') - expect(domain[:avail]).to eq('1') + res_data = response[:parsed].css('resData chkData cd name').first + res_data.text.should == 'one.ee' + res_data[:avail].should == '1' - domain = response[:parsed].css('resData chkData cd name').last - expect(domain.text).to eq('three.ee') - expect(domain[:avail]).to eq('1') + res_data = response[:parsed].css('resData chkData cd name').last + res_data.text.should == 'three.ee' + res_data[:avail].should == '1' end it 'checks invalid format domain' do @@ -1432,22 +1521,23 @@ describe 'EPP Domain', epp: true do ] }) - response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') + response = epp_plain_request(xml, :xml) + response[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' - domain = response[:parsed].css('resData chkData cd name').first - expect(domain.text).to eq('one.ee') - expect(domain[:avail]).to eq('1') + res_data = response[:parsed].css('resData chkData cd name').first + res_data.text.should == 'one.ee' + res_data[:avail].should == '1' - domain = response[:parsed].css('resData chkData cd').last - name = domain.css('name').first - reason = domain.css('reason').first + res_data = response[:parsed].css('resData chkData cd').last + name = res_data.css('name').first + reason = res_data.css('reason').first - expect(name.text).to eq('notcorrectdomain') - expect(name[:avail]).to eq('0') - expect(reason.text).to eq('invalid format') + name.text.should == 'notcorrectdomain' + name[:avail].should == '0' + reason.text.should == 'invalid format' end end + end diff --git a/spec/epp/epp_helper_spec.rb b/spec/epp/epp_helper_spec.rb index 0a0ccc80e..676925826 100644 --- a/spec/epp/epp_helper_spec.rb +++ b/spec/epp/epp_helper_spec.rb @@ -2,16 +2,19 @@ require 'rails_helper' describe 'EPP Helper', epp: true do context 'in context of Domain' do + before(:all) { @uniq_no = proc { @i ||= 0; @i += 1 } } + it 'generates valid transfer xml' do + dn = next_domain_name expected = Nokogiri::XML(' - example.ee + ' + dn + ' - 98oiewslkfkd + 98oiewslkfkd @@ -20,8 +23,8 @@ describe 'EPP Helper', epp: true do ').to_s.squish - generated = Nokogiri::XML(domain_transfer_xml).to_s.squish - expect(generated).to eq(expected) + generated = Nokogiri::XML(domain_transfer_xml(name: { value: dn })).to_s.squish + generated.should == expected expected = Nokogiri::XML(' @@ -48,7 +51,7 @@ describe 'EPP Helper', epp: true do }, 'approve') generated = Nokogiri::XML(xml).to_s.squish - expect(generated).to eq(expected) + generated.should == expected end end end diff --git a/spec/epp/keyrelay_spec.rb b/spec/epp/keyrelay_spec.rb index 62d5bc300..0d6dc2418 100644 --- a/spec/epp/keyrelay_spec.rb +++ b/spec/epp/keyrelay_spec.rb @@ -3,161 +3,169 @@ require 'rails_helper' describe 'EPP Keyrelay', epp: true do let(:server_zone) { Epp::Server.new({ server: 'localhost', tag: 'zone', password: 'ghyt9e4fu', port: 701 }) } let(:server_elkdata) { Epp::Server.new({ server: 'localhost', tag: 'elkdata', password: 'ghyt9e4fu', port: 701 }) } - let(:elkdata) { Fabricate(:registrar, { name: 'Elkdata', reg_no: '123' }) } - let(:zone) { Fabricate(:registrar) } - let(:domain) { Fabricate(:domain, name: 'example.ee', registrar: zone, dnskeys: [Fabricate.build(:dnskey)]) } let(:epp_xml) { EppXml::Keyrelay.new } before(:each) { create_settings } - context 'with valid user' do - before(:each) do - Fabricate(:epp_user, username: 'zone', registrar: zone) - Fabricate(:epp_user, username: 'elkdata', registrar: elkdata) - end + before(:all) do + @elkdata = Fabricate(:registrar, { name: 'Elkdata', reg_no: '123' }) + @zone = Fabricate(:registrar) + Fabricate(:epp_user, username: 'zone', registrar: @zone) + Fabricate(:epp_user, username: 'elkdata', registrar: @elkdata) - it 'makes a keyrelay request' do - xml = epp_xml.keyrelay({ - name: { value: 'example.ee' }, - keyData: { - flags: { value: '256' }, - protocol: { value: '3' }, - alg: { value: '8' }, - pubKey: { value: 'cmlraXN0aGViZXN0' } - }, - authInfo: { - pw: { value: domain.auth_info } - }, - expiry: { - relative: { value: 'P1M13D' } - } - }) + @uniq_no = proc { @i ||= 0; @i += 1 } + end - response = epp_request(xml, :xml, :elkdata) + before(:each) { Fabricate(:domain, name: next_domain_name, registrar: @zone, dnskeys: [Fabricate.build(:dnskey)]) } + let(:domain) { Domain.last } - expect(response[:msg]).to eq('Command completed successfully') - expect(response[:result_code]).to eq('1000') + it 'makes a keyrelay request' do + ApiLog::EppLog.delete_all - expect(zone.messages.queued.count).to eq(1) + xml = epp_xml.keyrelay({ + name: { value: domain.name }, + keyData: { + flags: { value: '256' }, + protocol: { value: '3' }, + alg: { value: '8' }, + pubKey: { value: 'cmlraXN0aGViZXN0' } + }, + authInfo: { + pw: { value: domain.auth_info } + }, + expiry: { + relative: { value: 'P1M13D' } + } + }) - log = ApiLog::EppLog.all + response = epp_request(xml, :xml, :elkdata) - expect(log.length).to eq(4) - expect(log[0].request_command).to eq('hello') - expect(log[0].request_successful).to eq(true) + response[:msg].should == 'Command completed successfully' + response[:result_code].should == '1000' - expect(log[1].request_command).to eq('login') - expect(log[1].request_successful).to eq(true) - expect(log[1].api_user_name).to eq('elkdata') - expect(log[1].api_user_registrar).to eq('Elkdata') + @zone.messages.queued.count.should == 1 - expect(log[2].request_command).to eq('keyrelay') - expect(log[2].request_object).to eq('keyrelay') - expect(log[2].request_successful).to eq(true) - expect(log[2].api_user_name).to eq('elkdata') - expect(log[2].api_user_registrar).to eq('Elkdata') - expect(log[2].request).not_to be_blank - expect(log[2].response).not_to be_blank + log = ApiLog::EppLog.all - expect(log[3].request_command).to eq('logout') - expect(log[3].request_successful).to eq(true) - expect(log[3].api_user_name).to eq('elkdata') - expect(log[3].api_user_registrar).to eq('Elkdata') - end + log.length.should == 4 + log[0].request_command.should == 'hello' + log[0].request_successful.should == true - it 'returns an error when parameters are missing' do - xml = epp_xml.keyrelay({ - name: { value: 'example.ee' }, - keyData: { - flags: { value: '' }, - protocol: { value: '3' }, - alg: { value: '8' }, - pubKey: { value: 'cmlraXN0aGViZXN0' } - }, - authInfo: { - pw: { value: domain.auth_info } - }, - expiry: { - relative: { value: 'Invalid Expiry' } - } - }) + log[1].request_command.should == 'login' + log[1].request_successful.should == true + log[1].api_user_name.should == 'elkdata' + log[1].api_user_registrar.should == 'Elkdata' - response = epp_request(xml, :xml, :elkdata) - expect(response[:msg]).to eq('Required parameter missing: flags') + log[2].request_command.should == 'keyrelay' + log[2].request_object.should == 'keyrelay' + log[2].request_successful.should == true + log[2].api_user_name.should == 'elkdata' + log[2].api_user_registrar.should == 'Elkdata' + log[2].request.should_not be_blank + log[2].response.should_not be_blank - expect(zone.messages.queued.count).to eq(0) - end + log[3].request_command.should == 'logout' + log[3].request_successful.should == true + log[3].api_user_name.should == 'elkdata' + log[3].api_user_registrar.should == 'Elkdata' + end - it 'returns an error on invalid relative expiry' do - xml = epp_xml.keyrelay({ - name: { value: 'example.ee' }, - keyData: { - flags: { value: '256' }, - protocol: { value: '3' }, - alg: { value: '8' }, - pubKey: { value: 'cmlraXN0aGViZXN0' } - }, - authInfo: { - pw: { value: domain.auth_info } - }, - expiry: { - relative: { value: 'Invalid Expiry' } - } - }) + it 'returns an error when parameters are missing' do + msg_count = @zone.messages.queued.count + xml = epp_xml.keyrelay({ + name: { value: domain.name }, + keyData: { + flags: { value: '' }, + protocol: { value: '3' }, + alg: { value: '8' }, + pubKey: { value: 'cmlraXN0aGViZXN0' } + }, + authInfo: { + pw: { value: domain.auth_info } + }, + expiry: { + relative: { value: 'Invalid Expiry' } + } + }) - response = epp_request(xml, :xml, :elkdata) - expect(response[:msg]).to eq('Expiry relative must be compatible to ISO 8601') - expect(response[:results][0][:value]).to eq('Invalid Expiry') + response = epp_request(xml, :xml, :elkdata) + response[:msg].should == 'Required parameter missing: flags' - expect(zone.messages.queued.count).to eq(0) - end + @zone.messages.queued.count.should == msg_count + end - it 'returns an error on invalid absolute expiry' do - xml = epp_xml.keyrelay({ - name: { value: 'example.ee' }, - keyData: { - flags: { value: '256' }, - protocol: { value: '3' }, - alg: { value: '8' }, - pubKey: { value: 'cmlraXN0aGViZXN0' } - }, - authInfo: { - pw: { value: domain.auth_info } - }, - expiry: { - absolute: { value: 'Invalid Absolute' } - } - }) + it 'returns an error on invalid relative expiry' do + msg_count = @zone.messages.queued.count + xml = epp_xml.keyrelay({ + name: { value: domain.name }, + keyData: { + flags: { value: '256' }, + protocol: { value: '3' }, + alg: { value: '8' }, + pubKey: { value: 'cmlraXN0aGViZXN0' } + }, + authInfo: { + pw: { value: domain.auth_info } + }, + expiry: { + relative: { value: 'Invalid Expiry' } + } + }) - response = epp_request(xml, :xml, :elkdata) - expect(response[:msg]).to eq('Expiry absolute must be compatible to ISO 8601') - expect(response[:results][0][:value]).to eq('Invalid Absolute') + response = epp_request(xml, :xml, :elkdata) + response[:msg].should == 'Expiry relative must be compatible to ISO 8601' + response[:results][0][:value].should == 'Invalid Expiry' - expect(zone.messages.queued.count).to eq(0) - end + @zone.messages.queued.count.should == msg_count + end - it 'does not allow both relative and absolute' do - xml = epp_xml.keyrelay({ - name: { value: 'example.ee' }, - keyData: { - flags: { value: '256' }, - protocol: { value: '3' }, - alg: { value: '8' }, - pubKey: { value: 'cmlraXN0aGViZXN0' } - }, - authInfo: { - pw: { value: domain.auth_info } - }, - expiry: { - relative: { value: 'P1D' }, - absolute: { value: '2014-12-23' } - } - }) + it 'returns an error on invalid absolute expiry' do + msg_count = @zone.messages.queued.count + xml = epp_xml.keyrelay({ + name: { value: domain.name }, + keyData: { + flags: { value: '256' }, + protocol: { value: '3' }, + alg: { value: '8' }, + pubKey: { value: 'cmlraXN0aGViZXN0' } + }, + authInfo: { + pw: { value: domain.auth_info } + }, + expiry: { + absolute: { value: 'Invalid Absolute' } + } + }) - response = epp_request(xml, :xml, :elkdata) - expect(response[:msg]).to eq('Exactly one parameter required: expiry > relative or expiry > absolute') + response = epp_request(xml, :xml, :elkdata) + response[:msg].should == 'Expiry absolute must be compatible to ISO 8601' + response[:results][0][:value].should == 'Invalid Absolute' - expect(zone.messages.queued.count).to eq(0) - end + @zone.messages.queued.count.should == msg_count + end + + it 'does not allow both relative and absolute' do + msg_count = @zone.messages.queued.count + xml = epp_xml.keyrelay({ + name: { value: domain.name }, + keyData: { + flags: { value: '256' }, + protocol: { value: '3' }, + alg: { value: '8' }, + pubKey: { value: 'cmlraXN0aGViZXN0' } + }, + authInfo: { + pw: { value: domain.auth_info } + }, + expiry: { + relative: { value: 'P1D' }, + absolute: { value: '2014-12-23' } + } + }) + + response = epp_request(xml, :xml, :elkdata) + response[:msg].should == 'Exactly one parameter required: expiry > relative or expiry > absolute' + + @zone.messages.queued.count.should == msg_count end end diff --git a/spec/epp/poll_spec.rb b/spec/epp/poll_spec.rb index 060d1e47e..befa5d2ca 100644 --- a/spec/epp/poll_spec.rb +++ b/spec/epp/poll_spec.rb @@ -1,159 +1,158 @@ require 'rails_helper' describe 'EPP Poll', epp: true do - let(:server_zone) { Epp::Server.new({ server: 'localhost', tag: 'zone', password: 'ghyt9e4fu', port: 701 }) } - let(:server_elkdata) { Epp::Server.new({ server: 'localhost', tag: 'elkdata', password: 'ghyt9e4fu', port: 701 }) } - let(:elkdata) { Fabricate(:registrar, { name: 'Elkdata', reg_no: '123' }) } - let(:zone) { Fabricate(:registrar) } let(:epp_xml) { EppXml::Session.new } - before(:each) { create_settings } + def registrar1 + @registrar1 ||= Registrar.where(reg_no: '12345678').first || Fabricate(:registrar) + end - context 'with valid user' do - before(:each) do - Fabricate(:epp_user, username: 'zone', registrar: zone) - Fabricate(:epp_user, username: 'elkdata', registrar: elkdata) + def registrar2 + @registrar2 ||= Fabricate(:registrar, { name: 'registrar2', reg_no: '123' }) + end + + before(:all) do + Fabricate(:epp_user, username: 'registrar1', registrar: registrar1) + Fabricate(:epp_user, username: 'registrar2', registrar: registrar2) + + login_as :registrar1 + + @uniq_no = proc { @i ||= 0; @i += 1 } + + create_settings + end + + it 'returns no messages in poll' do + ApiLog::EppLog.delete_all + response = epp_plain_request(epp_xml.poll, :xml) + + response[:msg].should == 'Command completed successfully; no messages' + response[:result_code].should == '1300' + + log = ApiLog::EppLog.last + + log.request_command.should == 'poll' + log.request_object.should == 'poll' + log.request_successful.should == true + log.api_user_name.should == 'registrar1' + log.api_user_registrar.should == 'Registrar OÜ' + log.request.should_not be_blank + log.response.should_not be_blank + end + + it 'queues and dequeues messages' do + msg = registrar1.messages.create({ body: 'Balance low.' }) + + response = login_as :registrar2 do + epp_plain_request(epp_xml.poll, :xml) end - it 'returns no messages in poll' do - response = epp_request(epp_xml.poll, :xml) + response[:msg].should == 'Command completed successfully; no messages' + response[:result_code].should == '1300' - expect(response[:msg]).to eq('Command completed successfully; no messages') - expect(response[:result_code]).to eq('1300') + response = epp_plain_request(epp_xml.poll, :xml) + response[:msg].should == 'Command completed successfully; ack to dequeue' + response[:result_code].should == '1301' + msg_q = response[:parsed].css('msgQ') - log = ApiLog::EppLog.all + msg_q.css('msg').text.should == 'Balance low.' + msg_q.first['count'].should == '1' + msg_q.first['id'].should == msg.id.to_s - expect(log.length).to eq(4) - expect(log[0].request_command).to eq('hello') - expect(log[0].request_successful).to eq(true) + xml = epp_xml.poll(poll: { + value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] } + }) - expect(log[1].request_command).to eq('login') - expect(log[1].request_successful).to eq(true) - expect(log[1].api_user_name).to eq('zone') - expect(log[1].api_user_registrar).to eq('Registrar OÜ') - - expect(log[2].request_command).to eq('poll') - expect(log[2].request_object).to eq('poll') - expect(log[2].request_successful).to eq(true) - expect(log[2].api_user_name).to eq('zone') - expect(log[2].api_user_registrar).to eq('Registrar OÜ') - expect(log[2].request).not_to be_blank - expect(log[2].response).not_to be_blank - - expect(log[3].request_command).to eq('logout') - expect(log[3].request_successful).to eq(true) - expect(log[3].api_user_name).to eq('zone') - expect(log[3].api_user_registrar).to eq('Registrar OÜ') + response = login_as :registrar2 do + epp_plain_request(xml, :xml) end - it 'queues and dequeues messages' do - msg = zone.messages.create({ body: 'Balance low.' }) + response[:results][0][:msg].should == 'Message was not found' + response[:results][0][:result_code].should == '2303' + response[:results][0][:value].should == msg_q.first['id'] - response = epp_request(epp_xml.poll, :xml, :elkdata) - expect(response[:msg]).to eq('Command completed successfully; no messages') - expect(response[:result_code]).to eq('1300') + response = epp_plain_request(xml, :xml) + response[:msg].should == 'Command completed successfully' + msg_q = response[:parsed].css('msgQ') + msg_q.first['id'].should_not be_blank + msg_q.first['count'].should == '0' - response = epp_request(epp_xml.poll, :xml, :zone) - expect(response[:msg]).to eq('Command completed successfully; ack to dequeue') - expect(response[:result_code]).to eq('1301') - msg_q = response[:parsed].css('msgQ') + response = epp_plain_request(xml, :xml) + response[:results][0][:msg].should == 'Message was not found' + response[:results][0][:result_code].should == '2303' + response[:results][0][:value].should == msg_q.first['id'] + end - expect(msg_q.css('msg').text).to eq('Balance low.') - expect(msg_q.first['count']).to eq('1') - expect(msg_q.first['id']).to eq(msg.id.to_s) + it 'returns an error on incorrect op' do + xml = epp_xml.poll(poll: { + value: '', attrs: { op: 'bla' } + }) - xml = epp_xml.poll(poll: { - value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] } - }) + response = epp_plain_request(xml, :xml) + response[:msg].should == 'Attribute op is invalid' + end - response = epp_request(xml, :xml, :elkdata) - expect(response[:results][0][:msg]).to eq('Message was not found') - expect(response[:results][0][:result_code]).to eq('2303') - expect(response[:results][0][:value]).to eq(msg_q.first['id']) + it 'dequeues multiple messages' do + registrar1.messages.create({ body: 'Balance low.' }) + registrar1.messages.create({ body: 'Something.' }) + registrar1.messages.create({ body: 'Smth else.' }) - response = epp_request(xml, :xml, :zone) - expect(response[:msg]).to eq('Command completed successfully') - msg_q = response[:parsed].css('msgQ') - expect(msg_q.first['id']).to_not be_blank - expect(msg_q.first['count']).to eq('0') + response = epp_plain_request(epp_xml.poll, :xml) + response[:msg].should == 'Command completed successfully; ack to dequeue' + response[:result_code].should == '1301' + msg_q = response[:parsed].css('msgQ') - response = epp_request(xml, :xml, :zone) - expect(response[:results][0][:msg]).to eq('Message was not found') - expect(response[:results][0][:result_code]).to eq('2303') - expect(response[:results][0][:value]).to eq(msg_q.first['id']) - end + msg_q.css('msg').text.should == 'Smth else.' + msg_q.first['count'].should == '3' - it 'returns an error on incorrect op' do - xml = epp_xml.poll(poll: { - value: '', attrs: { op: 'bla' } - }) + xml = epp_xml.poll(poll: { + value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] } + }) - response = epp_request(xml, :xml, :zone) - expect(response[:msg]).to eq('Attribute op is invalid') - end + response = epp_plain_request(xml, :xml) + response[:msg].should == 'Command completed successfully' + msg_q = response[:parsed].css('msgQ') + msg_q.first['id'].should_not be_blank + msg_q.first['count'].should == '2' - it 'dequeues multiple messages' do - zone.messages.create({ body: 'Balance low.' }) - zone.messages.create({ body: 'Something.' }) - zone.messages.create({ body: 'Smth else.' }) + response = epp_plain_request(epp_xml.poll, :xml) + response[:msg].should == 'Command completed successfully; ack to dequeue' + response[:result_code].should == '1301' + msg_q = response[:parsed].css('msgQ') - response = epp_request(epp_xml.poll, :xml, :zone) - expect(response[:msg]).to eq('Command completed successfully; ack to dequeue') - expect(response[:result_code]).to eq('1301') - msg_q = response[:parsed].css('msgQ') + msg_q.css('msg').text.should == 'Something.' + msg_q.first['count'].should == '2' - expect(msg_q.css('msg').text).to eq('Smth else.') - expect(msg_q.first['count']).to eq('3') + xml = epp_xml.poll(poll: { + value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] } + }) - xml = epp_xml.poll(poll: { - value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] } - }) + response = epp_plain_request(xml, :xml) + response[:msg].should == 'Command completed successfully' + msg_q = response[:parsed].css('msgQ') + msg_q.first['id'].should_not be_blank + msg_q.first['count'].should == '1' - response = epp_request(xml, :xml, :zone) - expect(response[:msg]).to eq('Command completed successfully') - msg_q = response[:parsed].css('msgQ') - expect(msg_q.first['id']).to_not be_blank - expect(msg_q.first['count']).to eq('2') + response = epp_plain_request(epp_xml.poll, :xml) + response[:msg].should == 'Command completed successfully; ack to dequeue' + response[:result_code].should == '1301' + msg_q = response[:parsed].css('msgQ') - response = epp_request(epp_xml.poll, :xml, :zone) - expect(response[:msg]).to eq('Command completed successfully; ack to dequeue') - expect(response[:result_code]).to eq('1301') - msg_q = response[:parsed].css('msgQ') + msg_q.css('msg').text.should == 'Balance low.' + msg_q.first['count'].should == '1' - expect(msg_q.css('msg').text).to eq('Something.') - expect(msg_q.first['count']).to eq('2') + xml = epp_xml.poll(poll: { + value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] } + }) - xml = epp_xml.poll(poll: { - value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] } - }) + response = epp_plain_request(xml, :xml) + response[:msg].should == 'Command completed successfully' + msg_q = response[:parsed].css('msgQ') + msg_q.first['id'].should_not be_blank + msg_q.first['count'].should == '0' - response = epp_request(xml, :xml, :zone) - expect(response[:msg]).to eq('Command completed successfully') - msg_q = response[:parsed].css('msgQ') - expect(msg_q.first['id']).to_not be_blank - expect(msg_q.first['count']).to eq('1') - - response = epp_request(epp_xml.poll, :xml, :zone) - expect(response[:msg]).to eq('Command completed successfully; ack to dequeue') - expect(response[:result_code]).to eq('1301') - msg_q = response[:parsed].css('msgQ') - - expect(msg_q.css('msg').text).to eq('Balance low.') - expect(msg_q.first['count']).to eq('1') - - xml = epp_xml.poll(poll: { - value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] } - }) - - response = epp_request(xml, :xml, :zone) - expect(response[:msg]).to eq('Command completed successfully') - msg_q = response[:parsed].css('msgQ') - expect(msg_q.first['id']).to_not be_blank - expect(msg_q.first['count']).to eq('0') - - response = epp_request(epp_xml.poll, :xml, :zone) - expect(response[:msg]).to eq('Command completed successfully; no messages') - expect(response[:result_code]).to eq('1300') - end + response = epp_plain_request(epp_xml.poll, :xml) + response[:msg].should == 'Command completed successfully; no messages' + response[:result_code].should == '1300' end end diff --git a/spec/epp/session_spec.rb b/spec/epp/session_spec.rb index f7c728385..c11f7c5f9 100644 --- a/spec/epp/session_spec.rb +++ b/spec/epp/session_spec.rb @@ -1,86 +1,85 @@ require 'rails_helper' describe 'EPP Session', epp: true do - let(:server_gitlab) { Epp::Server.new({ server: 'localhost', tag: 'gitlab', password: 'ghyt9e4fu', port: 701 }) } - let(:epp_xml) { EppXml.new(cl_trid: 'ABC-12345') } - let(:login_xml_cache) { epp_xml.session.login(clID: { value: 'gitlab' }, pw: { value: 'ghyt9e4fu' }) } + before :all do + @epp_user = Fabricate(:epp_user) + @epp_xml = EppXml.new(cl_trid: 'ABC-12345') + @login_xml_cache = @epp_xml.session.login(clID: { value: 'gitlab' }, pw: { value: 'ghyt9e4fu' }) + + end context 'when not connected' do it 'greets client upon connection' do - response = Nokogiri::XML(server_gitlab.open_connection) - expect(response.css('epp svID').text).to eq('EPP server (EIS)') - server_gitlab.close_connection - + response = Nokogiri::XML(server.open_connection) + response.css('epp svID').text.should == 'EPP server (EIS)' puts "RESPONSE:\n\n```xml\n#{response}```\n\n" if ENV['EPP_DOC'] end end context 'when connected' do - before(:each) { server_gitlab.open_connection } - after(:each) { server_gitlab.close_connection } - - context 'with valid user' do - before(:each) { Fabricate(:epp_user) } - - it 'logs in epp user' do - response = epp_plain_request(login_xml_cache, :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') - expect(response[:clTRID]).to eq('ABC-12345') - end - - it 'logs out epp user' do - epp_plain_request(login_xml_cache, :xml) - - expect(EppSession.first[:epp_user_id]).to eq(1) - response = epp_plain_request(epp_xml.session.logout, :xml) - expect(response[:result_code]).to eq('1500') - expect(response[:msg]).to eq('Command completed successfully; ending session') - - expect(EppSession.first[:epp_user_id]).to eq(nil) - end - - it 'does not log in twice' do - epp_plain_request(login_xml_cache, :xml) - - response = epp_plain_request(login_xml_cache, :xml) - expect(response[:result_code]).to eq('2002') - expect(response[:msg]).to match(/Already logged in. Use/) - - log = ApiLog::EppLog.all - expect(log.length).to eq(3) - expect(log[0].request_command).to eq('hello') - expect(log[0].request_successful).to eq(true) - - expect(log[1].request_command).to eq('login') - expect(log[1].request_successful).to eq(true) - expect(log[1].api_user_name).to eq('gitlab') - expect(log[1].api_user_registrar).to eq('Registrar OÜ') - - expect(log[2].request_command).to eq('login') - expect(log[2].request_successful).to eq(false) - expect(log[2].api_user_name).to eq('gitlab') - expect(log[2].api_user_registrar).to eq('Registrar OÜ') - end + before do + server.open_connection end it 'does not log in with invalid user' do - response = epp_plain_request(login_xml_cache, :xml) - expect(response[:result_code]).to eq('2501') - expect(response[:msg]).to eq('Authentication error; server closing connection') - expect(response[:clTRID]).to eq('ABC-12345') + wrong_user = @epp_xml.session.login(clID: { value: 'wrong-user' }, pw: { value: 'ghyt9e4fu' }) + response = epp_plain_request(wrong_user, :xml) + response[:msg].should == 'Authentication error; server closing connection' + response[:result_code].should == '2501' + response[:clTRID].should == 'ABC-12345' + end - Fabricate(:epp_user, active: false) + it 'does not log in with inactive user' do + @registrar = Fabricate(:registrar, { name: 'registrar1', reg_no: '123' }) + Fabricate(:epp_user, username: 'inactive-user', active: false, registrar: @registrar) - response = epp_plain_request(login_xml_cache, :xml) - expect(response[:result_code]).to eq('2501') + inactive = @epp_xml.session.login(clID: { value: 'inactive-user' }, pw: { value: 'ghyt9e4fu' }) + response = epp_plain_request(inactive, :xml) + response[:result_code].should == '2501' end it 'prohibits further actions unless logged in' do - response = epp_plain_request(epp_xml.domain.create, :xml) - expect(response[:result_code]).to eq('2002') - expect(response[:msg]).to eq('You need to login first.') - expect(response[:clTRID]).to eq('ABC-12345') + response = epp_plain_request(@epp_xml.domain.create, :xml) + response[:msg].should == 'You need to login first.' + response[:result_code].should == '2002' + response[:clTRID].should == 'ABC-12345' + end + + context 'with valid user' do + it 'logs in epp user' do + response = epp_plain_request(@login_xml_cache, :xml) + response[:msg].should == 'Command completed successfully' + response[:result_code].should == '1000' + response[:clTRID].should == 'ABC-12345' + end + + it 'does not log in twice' do + response = epp_plain_request(@login_xml_cache, :xml) + response[:msg].should == 'Command completed successfully' + response[:result_code].should == '1000' + response[:clTRID].should == 'ABC-12345' + + response = epp_plain_request(@login_xml_cache, :xml) + response[:msg].should match(/Already logged in. Use/) + response[:result_code].should == '2002' + + log = ApiLog::EppLog.last + log.request_command.should == 'login' + log.request_successful.should == false + log.api_user_name.should == 'gitlab' + log.api_user_registrar.should == 'Registrar OÜ' + end + + it 'logs out epp user' do + epp_plain_request(@login_xml_cache, :xml) + + EppSession.last[:epp_user_id].should == 1 + response = epp_plain_request(@epp_xml.session.logout, :xml) + response[:msg].should == 'Command completed successfully; ending session' + response[:result_code].should == '1500' + + EppSession.last[:epp_user_id].should == nil + end end end end diff --git a/spec/fabricators/contact_fabricator.rb b/spec/fabricators/contact_fabricator.rb index 6bd604e79..c483ad554 100644 --- a/spec/fabricators/contact_fabricator.rb +++ b/spec/fabricators/contact_fabricator.rb @@ -1,9 +1,9 @@ Fabricator(:contact) do - name Faker::Name.name + name { sequence(:name) { |i| "#{Faker::Name.name}#{i}" } } phone '+372.12345678' email Faker::Internet.email ident '37605030299' - code { "sh#{Faker::Number.number(4)}" } + code { "sh#{Faker::Number.number(8)}" } ident_type 'op' auth_info 'ccds4324pok' address diff --git a/spec/models/contact_spec.rb b/spec/models/contact_spec.rb index d06b23525..1bb2af44d 100644 --- a/spec/models/contact_spec.rb +++ b/spec/models/contact_spec.rb @@ -1,6 +1,11 @@ require 'rails_helper' describe Contact do + before :all do + # DatabaseCleaner.clean_with(:truncation) + # DatabaseCleaner.strategy = :transaction + end + before { create_disclosure_settings } it { should have_one(:address) } @@ -76,6 +81,11 @@ describe Contact do end context 'with callbacks' do + before :all do + Contact.set_callback(:create, :before, :generate_code) + Contact.set_callback(:create, :before, :generate_auth_info) + end + before(:each) { @contact = Fabricate.build(:contact, code: '123asd', auth_info: 'qwe321') } context 'after create' do diff --git a/spec/models/domain_spec.rb b/spec/models/domain_spec.rb index b61c2aa19..733ce22f6 100644 --- a/spec/models/domain_spec.rb +++ b/spec/models/domain_spec.rb @@ -15,52 +15,52 @@ describe Domain do create_settings end - it 'validates domain name', skip: true do - d = Fabricate(:domain) - expect(d.name).to_not be_nil + # it 'validates domain name', skip: true do + # d = Fabricate(:domain) + # expect(d.name).to_not be_nil - invalid = ['a.ee', "#{'a' * 64}.ee", 'ab.eu', 'test.ab.ee', '-test.ee', '-test-.ee', 'test-.ee', 'te--st.ee', - 'õ.pri.ee', 'test.com', 'www.ab.ee', 'test.eu', ' .ee', 'a b.ee', 'Ž .ee', 'test.edu.ee'] + # invalid = ['a.ee', "#{'a' * 64}.ee", 'ab.eu', 'test.ab.ee', '-test.ee', '-test-.ee', 'test-.ee', 'te--st.ee', + # 'õ.pri.ee', 'test.com', 'www.ab.ee', 'test.eu', ' .ee', 'a b.ee', 'Ž .ee', 'test.edu.ee'] - invalid.each do |x| - expect(Fabricate.build(:domain, name: x).valid?).to be false - end + # invalid.each do |x| + # expect(Fabricate.build(:domain, name: x).valid?).to be false + # end - valid = ['ab.ee', "#{'a' * 63}.ee", 'te-s-t.ee', 'jäääär.ee', 'päike.pri.ee', - 'õigus.com.ee', 'õäöü.fie.ee', 'test.med.ee', 'žä.ee', ' ŽŠ.ee '] + # valid = ['ab.ee', "#{'a' * 63}.ee", 'te-s-t.ee', 'jäääär.ee', 'päike.pri.ee', + # 'õigus.com.ee', 'õäöü.fie.ee', 'test.med.ee', 'žä.ee', ' ŽŠ.ee '] - valid.each do |x| - expect(Fabricate.build(:domain, name: x).valid?).to be true - end + # valid.each do |x| + # expect(Fabricate.build(:domain, name: x).valid?).to be true + # end - invalid_punycode = ['xn--geaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-4we.pri.ee'] + # invalid_punycode = ['xn--geaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-4we.pri.ee'] - invalid_punycode.each do |x| - expect(Fabricate.build(:domain, name: x).valid?).to be false - end + # invalid_punycode.each do |x| + # expect(Fabricate.build(:domain, name: x).valid?).to be false + # end - valid_punycode = ['xn--ge-uia.pri.ee', 'xn--geaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-9te.pri.ee'] + # valid_punycode = ['xn--ge-uia.pri.ee', 'xn--geaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-9te.pri.ee'] - valid_punycode.each do |x| - expect(Fabricate.build(:domain, name: x).valid?).to be true - end + # valid_punycode.each do |x| + # expect(Fabricate.build(:domain, name: x).valid?).to be true + # end - d = Domain.new - expect(d.valid?).to be false - expect(d.errors.messages).to match_array({ - owner_contact: ['Registrant is missing'], - admin_contacts: ['Admin contacts count must be between 1 - infinity'], - nameservers: ['Nameservers count must be between 2-11'], - registrar: ['Registrar is missing'], - period: ['Period is not a number'] - }) + # d = Domain.new + # expect(d.valid?).to be false + # expect(d.errors.messages).to match_array({ + # owner_contact: ['Registrant is missing'], + # admin_contacts: ['Admin contacts count must be between 1 - infinity'], + # nameservers: ['Nameservers count must be between 2-11'], + # registrar: ['Registrar is missing'], + # period: ['Period is not a number'] + # }) - Setting.ns_min_count = 2 - Setting.ns_max_count = 7 + # Setting.ns_min_count = 2 + # Setting.ns_max_count = 7 - expect(d.valid?).to be false - expect(d.errors.messages[:nameservers]).to eq(['Nameservers count must be between 2-7']) - end + # expect(d.valid?).to be false + # expect(d.errors.messages[:nameservers]).to eq(['Nameservers count must be between 2-7']) + # end it 'downcases domain' do d = Domain.new(name: 'TesT.Ee') diff --git a/spec/rails_helper.rb b/spec/rails_helper.rb index 6854b17dd..403680d20 100644 --- a/spec/rails_helper.rb +++ b/spec/rails_helper.rb @@ -33,17 +33,18 @@ RSpec.configure do |config| config.before(:suite) do ActiveRecord::Base.establish_connection :api_log_test - DatabaseCleaner.strategy = :deletion + DatabaseCleaner.clean_with(:truncation) + DatabaseCleaner.strategy = nil + ActiveRecord::Base.establish_connection :test - DatabaseCleaner.strategy = :truncation end - config.before(:each) do - DatabaseCleaner.strategy = :transaction + config.before(:all) do + DatabaseCleaner.clean_with(:truncation) end - config.before(:each, epp: true) do - DatabaseCleaner.strategy = :truncation + config.before(:all, epp: true) do + DatabaseCleaner.strategy = nil end config.before(:each, js: true) do @@ -54,19 +55,12 @@ RSpec.configure do |config| DatabaseCleaner.strategy = :truncation end - config.before(:each) do - ActiveRecord::Base.establish_connection :api_log_test - DatabaseCleaner.start - - ActiveRecord::Base.establish_connection :test + config.before(:each, type: :model) do + DatabaseCleaner.strategy = :transaction DatabaseCleaner.start end - config.after(:each) do - ActiveRecord::Base.establish_connection :api_log_test - DatabaseCleaner.clean - - ActiveRecord::Base.establish_connection :test + config.after(:each, type: :model) do DatabaseCleaner.clean end @@ -88,6 +82,6 @@ RSpec.configure do |config| config.infer_spec_type_from_file_location! config.expect_with :rspec do |c| - c.syntax = :expect + c.syntax = [:should, :expect] end end diff --git a/spec/requests/domain_v1_spec.rb b/spec/requests/domain_v1_spec.rb index 0e362179a..a622b6828 100644 --- a/spec/requests/domain_v1_spec.rb +++ b/spec/requests/domain_v1_spec.rb @@ -18,7 +18,7 @@ describe Repp::DomainV1 do # TODO: Maybe there is a way not to convert from and to json again expect(body['domains'].to_json).to eq(epp_user.registrar.domains.to_json) - log = ApiLog::ReppLog.first + log = ApiLog::ReppLog.last expect(log[:request_path]).to eq('/repp/v1/domains') expect(log[:request_method]).to eq('GET') expect(log[:request_params]).to eq('{}') diff --git a/spec/support/epp.rb b/spec/support/epp.rb index 52250d63c..3bceb034d 100644 --- a/spec/support/epp.rb +++ b/spec/support/epp.rb @@ -1,4 +1,47 @@ module Epp + # Example usage: + # + # login_as :gitlab + # + # Use block for temp login: + # + # login_as :registrar1 do + # your test code + # # will make request as registrar1 and logins back to previous session + # end + # + def login_as(user) + server.open_connection + + if block_given? + begin + epp_plain_request(login_xml_for(user), :xml) + yield + ensure + server.open_connection # return back to last login + epp_plain_request(login_xml_for(@last_user), :xml) + end + else + @last_user = user # save for block + epp_plain_request(login_xml_for(user), :xml) + end + end + + def login_xml_for(user) + @xml ||= EppXml.new(cl_trid: 'ABC-12345') + case user + when :gitlab + @gitlab_login_xml ||= + @xml.session.login(clID: { value: 'gitlab' }, pw: { value: 'ghyt9e4fu' }) + when :registrar1 + @registrar1_login_xml ||= + @xml.session.login(clID: { value: 'registrar1' }, pw: { value: 'ghyt9e4fu' }) + when :registrar2 + @registrar2_login_xml ||= + @xml.session.login(clID: { value: 'registrar2' }, pw: { value: 'ghyt9e4fu' }) + end + end + def read_body(filename) File.read("spec/epp/requests/#{filename}") end @@ -23,10 +66,6 @@ module Epp end def epp_plain_request(data, *args) - server = server_gitlab - server = server_elkdata if args.include?(:elkdata) - server = server_zone if args.include?(:zone) - res = parse_response(server.send_request(data)) if args.include?(:xml) if res log(data, res[:parsed]) @@ -39,6 +78,11 @@ module Epp rescue => e e end + + def server + # tag and password not in use, add those at login xml + @server ||= Epp::Server.new({ server: 'localhost', port: 701, tag: '', password: '' }) + end def parse_response(raw) res = Nokogiri::XML(raw) @@ -67,11 +111,15 @@ module Epp puts r[:parsed].to_s end + def next_domain_name + "example#{@uniq_no.call}.ee" + end + ### REQUEST TEMPLATES ### def domain_info_xml(xml_params = {}) defaults = { - name: { value: 'example.ee', attrs: { hosts: 'all' } }, + name: { value: next_domain_name, attrs: { hosts: 'all' } }, authInfo: { pw: { value: '2fooBAR' } } @@ -86,7 +134,7 @@ module Epp # rubocop: disable Metrics/MethodLength def domain_create_xml(xml_params = {}, dnssec_params = {}) defaults = { - name: { value: 'example.ee' }, + name: { value: next_domain_name }, period: { value: '1', attrs: { unit: 'y' } }, ns: [ { @@ -102,7 +150,7 @@ module Epp } } ], - registrant: { value: 'jd1234' }, + registrant: { value: 'citizen_1234' }, _anonymus: [ { contact: { value: 'sh8013', attrs: { type: 'admin' } } }, { contact: { value: 'sh8013', attrs: { type: 'tech' } } }, @@ -138,11 +186,9 @@ module Epp epp_xml.create(xml_params, dnssec_params, custom_params) end - def domain_create_xml_with_legal_doc - epp_xml = EppXml::Domain.new(cl_trid: 'ABC-12345') - - epp_xml.create({ - name: { value: 'example.ee' }, + def domain_create_xml_with_legal_doc(xml_params = {}) + defaults = { + name: { value: next_domain_name }, period: { value: '1', attrs: { unit: 'y' } }, ns: [ { @@ -158,13 +204,19 @@ module Epp } } ], - registrant: { value: 'jd1234' }, + registrant: { value: 'citizen_1234' }, _anonymus: [ { contact: { value: 'sh8013', attrs: { type: 'admin' } } }, { contact: { value: 'sh8013', attrs: { type: 'tech' } } }, { contact: { value: 'sh801333', attrs: { type: 'tech' } } } ] - }, {}, { + } + + xml_params = defaults.deep_merge(xml_params) + + epp_xml = EppXml::Domain.new(cl_trid: 'ABC-12345') + + epp_xml.create(xml_params, {}, { _anonymus: [ legalDocument: { value: 'JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0Zp==', @@ -176,7 +228,7 @@ module Epp def domain_create_with_invalid_ns_ip_xml xml_params = { - name: { value: 'example.ee' }, + name: { value: next_domain_name }, period: { value: '1', attrs: { unit: 'y' } }, ns: [ { @@ -192,7 +244,7 @@ module Epp } } ], - registrant: { value: 'jd1234' }, + registrant: { value: 'citizen_1234' }, _anonymus: [ { contact: { value: 'sh8013', attrs: { type: 'admin' } } }, { contact: { value: 'sh8013', attrs: { type: 'tech' } } }, @@ -220,7 +272,7 @@ module Epp def domain_create_with_host_attrs xml_params = { - name: { value: 'example.ee' }, + name: { value: next_domain_name }, period: { value: '1', attrs: { unit: 'y' } }, ns: [ { @@ -236,7 +288,7 @@ module Epp } } ], - registrant: { value: 'jd1234' }, + registrant: { value: 'citizen_1234' }, _anonymus: [ { contact: { value: 'sh8013', attrs: { type: 'admin' } } }, { contact: { value: 'sh8013', attrs: { type: 'tech' } } }, @@ -264,7 +316,7 @@ module Epp def domain_update_xml(xml_params = {}, dnssec_params = {}, custom_params = {}) defaults = { - name: { value: 'example.ee' } + name: { value: next_domain_name } } xml_params = defaults.deep_merge(xml_params) @@ -275,7 +327,7 @@ module Epp def domain_check_xml(xml_params = {}) defaults = { _anonymus: [ - { name: { value: 'example.ee' } } + { name: { value: next_domain_name } } ] } xml_params = defaults.deep_merge(xml_params) @@ -285,9 +337,9 @@ module Epp def domain_transfer_xml(xml_params = {}, op = 'query', custom_params = {}) defaults = { - name: { value: 'example.ee' }, + name: { value: next_domain_name }, authInfo: { - pw: { value: '98oiewslkfkd', attrs: { roid: 'JD1234-REP' } } + pw: { value: '98oiewslkfkd', attrs: { roid: 'citizen_1234-REP' } } } }