diff --git a/app/controllers/epp_controller.rb b/app/controllers/epp_controller.rb index 1c0bfea43..32ffaf156 100644 --- a/app/controllers/epp_controller.rb +++ b/app/controllers/epp_controller.rb @@ -124,7 +124,7 @@ class EppController < ApplicationController # rubocop: enable Style/PredicateName def write_to_epp_log - return nil if EPP_LOG_ENABLED + # 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/spec/epp/domain_spec.rb b/spec/epp/domain_spec.rb index 0f081568f..ad31e0d20 100644 --- a/spec/epp/domain_spec.rb +++ b/spec/epp/domain_spec.rb @@ -34,39 +34,39 @@ describe 'EPP Domain', epp: true do ] }), :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('sh1111') + response[:results][0][:result_code].should == '2303' + response[:results][0][:msg].should == 'Contact was not found' + response[:results][0][:value].should == 'sh1111' - 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('sh2222') + response[:results][1][:result_code].should == '2303' + response[:results][1][:msg].should == 'Contact was not found' + response[:results][1][:value].should == 'sh2222' - expect(response[:clTRID]).to eq('ABC-12345') + response[:clTRID].should == 'ABC-12345' log = ApiLog::EppLog.last(4) - expect(log.length).to eq(4) - expect(log[0].request_command).to eq('hello') - expect(log[0].request_successful).to eq(true) + log.length.should == 4 + log[0].request_command.should == 'hello' + log[0].request_successful.should == 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Ü') + log[1].request_command.should == 'login' + log[1].request_successful.should == true + log[1].api_user_name.should == 'zone' + log[1].api_user_registrar.should == '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 + log[2].request_command.should == 'create' + log[2].request_object.should == 'domain' + log[2].request_successful.should == false + log[2].api_user_name.should == 'zone' + log[2].api_user_registrar.should == 'Registrar OÜ' + log[2].request.should_not be_blank + log[2].response.should_not 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[3].request_command.should == 'logout' + log[3].request_successful.should == true + log[3].api_user_name.should == 'zone' + log[3].api_user_registrar.should == 'Registrar OÜ' end it 'validates required parameters' do @@ -76,17 +76,17 @@ describe 'EPP Domain', epp: true do }) 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') + response[:results][0][:result_code].should == '2003' + response[:results][0][:msg].should == 'Required parameter missing: ns' - expect(response[:results][1][:result_code]).to eq('2003') - expect(response[:results][1][:msg]).to eq('Required parameter missing: registrant') + response[:results][1][:result_code].should == '2003' + response[:results][1][:msg].should == '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') + response[:results][2][:result_code].should == '2003' + response[:results][2][:msg].should == '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') + 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 @@ -96,45 +96,45 @@ describe 'EPP Domain', epp: true do name: { value: dn } }), :xml) d = Domain.last - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') + response[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' cre_data = response[:parsed].css('creData') - expect(cre_data.css('name').text).to eq(dn) - 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) + 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 - expect(response[:clTRID]).to eq('ABC-12345') + response[:clTRID].should == '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 + d.registrar.name.should == 'Registrar OÜ' + d.tech_contacts.count.should == 2 + d.admin_contacts.count.should == 1 - expect(d.nameservers.count).to eq(2) - expect(d.auth_info).not_to be_empty + d.nameservers.count.should == 2 + d.auth_info.should_not be_empty - expect(d.dnskeys.count).to eq(1) + d.dnskeys.count.should == 1 key = d.dnskeys.last - expect(key.ds_alg).to eq(3) - expect(key.ds_key_tag).to_not be_blank + key.ds_alg.should == 3 + key.ds_key_tag.should_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') + 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 'creates a domain with legal document' do response = epp_request(domain_create_xml_with_legal_doc, :xml) - expect(response[:msg]).to eq('Command completed successfully') - expect(response[:result_code]).to eq('1000') + response[:msg].should == 'Command completed successfully' + response[:result_code].should == '1000' d = Domain.last - expect(d.legal_documents.count).to eq(1) + d.legal_documents.count.should == 1 end it 'creates ria.ee with valid ds record' do @@ -160,7 +160,7 @@ describe 'EPP Domain', epp: true do epp_request(xml, :xml) d = Domain.last ds = d.dnskeys.last - expect(ds.ds_digest).to eq('0B62D1BC64EFD1EE652FB102BDF1011BF514CCD9A1A0CFB7472AEA3B01F38C92') + ds.ds_digest.should == '0B62D1BC64EFD1EE652FB102BDF1011BF514CCD9A1A0CFB7472AEA3B01F38C92' end it 'validates nameserver ipv4 when in same zone as domain' do @@ -182,8 +182,8 @@ describe 'EPP Domain', epp: true do }) response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2306') - expect(response[:msg]).to eq('IPv4 is missing') + response[:result_code].should == '2306' + response[:msg].should == 'IPv4 is missing' end it 'does not create duplicate domain' do @@ -195,33 +195,33 @@ describe 'EPP Domain', epp: true do name: { value: dn } }), :xml) - expect(response[:result_code]).to eq('2302') - expect(response[:msg]).to eq('Domain name already exists') - expect(response[:clTRID]).to eq('ABC-12345') + 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_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') + 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_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('2003') - expect(response[:results][0][:msg]).to eq('Required parameter missing: registrant') + 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_request(xml, :xml) - expect(response[:result_code]).to eq('2003') - expect(response[:msg]).to eq('Required parameter missing: ns') + response[:result_code].should == '2003' + response[:msg].should == 'Required parameter missing: ns' end it 'does not create domain with too many nameservers' do @@ -239,8 +239,8 @@ describe 'EPP Domain', epp: true do }) response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2004') - expect(response[:msg]).to eq('Nameservers count must be between 2-11') + 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 @@ -260,8 +260,8 @@ describe 'EPP Domain', epp: true do }) response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2005') - expect(response[:msg]).to eq('Hostname is invalid') + response[:result_code].should == '2005' + response[:msg].should == 'Hostname is invalid' end it 'checks hostAttr presence' do @@ -277,40 +277,40 @@ describe 'EPP Domain', epp: true do }) response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2003') - expect(response[:msg]).to eq('Required parameter missing: ns > hostAttr') + response[:result_code].should == '2003' + response[:msg].should == 'Required parameter missing: ns > hostAttr' end it 'creates domain with nameservers with ips' do epp_request(domain_create_with_host_attrs, :xml) - expect(Domain.last.nameservers.count).to eq(2) + Domain.last.nameservers.count.should == 2 ns = Domain.last.nameservers.first - expect(ns.ipv4).to eq('192.0.2.2') - expect(ns.ipv6).to eq('1080:0:0:0:8:800:200C:417A') + ns.ipv4.should == '192.0.2.2' + ns.ipv6.should == '1080:0:0:0:8:800:200C:417A' end it 'returns error when nameserver has invalid ips' do domain_count = Domain.count nameserver_count = Nameserver.count 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' + 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: - expect(Domain.count).to eq(domain_count) - expect(Nameserver.count).to eq(nameserver_count) + Domain.count.should == domain_count + Nameserver.count.should == nameserver_count 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) + response[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' + Domain.first.valid_to.should == Date.today + 1.year end it 'does not create a domain with invalid period' do @@ -319,9 +319,9 @@ describe 'EPP Domain', epp: true do }) 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') + 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 it 'creates a domain with multiple dnskeys' do @@ -356,17 +356,17 @@ describe 'EPP Domain', epp: true do epp_request(xml, :xml) d = Domain.last - expect(d.dnskeys.count).to eq(3) + d.dnskeys.count.should == 3 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) + key_1.ds_key_tag.should_not be_blank + key_1.ds_alg.should == 3 + key_1.ds_digest_type.should == Setting.ds_algorithm - 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( + 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 @@ -405,25 +405,25 @@ describe 'EPP Domain', epp: true do response = epp_request(xml, :xml) - 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') + response[:results][0][:msg].should == 'Valid algorithms are: 3, 5, 6, 7, 8, 252, 253, 254, 255' + response[:results][0][:value].should == '9' - expect(response[:results][1][:msg]).to eq('Valid protocols are: 3') - expect(response[:results][1][:value]).to eq('4') + response[:results][1][:msg].should == 'Valid protocols are: 3' + response[:results][1][:value].should == '4' - expect(response[:results][2][:msg]).to eq('Valid flags are: 0, 256, 257') - expect(response[:results][2][:value]).to eq('250') + response[:results][2][:msg].should == 'Valid flags are: 0, 256, 257' + response[:results][2][:value].should == '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') + response[:results][3][:msg].should == 'Valid algorithms are: 3, 5, 6, 7, 8, 252, 253, 254, 255' + response[:results][3][:value].should == '10' - expect(response[:results][4][:msg]).to eq('Valid flags are: 0, 256, 257') - expect(response[:results][4][:value]).to eq('1') + response[:results][4][:msg].should == 'Valid flags are: 0, 256, 257' + response[:results][4][:value].should == '1' - expect(response[:results][5][:msg]).to eq('Public key is missing') + response[:results][5][:msg].should == 'Public key is missing' - expect(response[:results][6][:msg]).to eq('Valid protocols are: 3') - expect(response[:results][6][:value]).to eq('5') + 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 @@ -448,9 +448,9 @@ describe 'EPP Domain', epp: true do 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') + response[:result_code].should == '2302' + response[:msg].should == 'Public key already exists' + response[:results][0][:value].should == '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' end it 'validated dnskeys count' do @@ -477,8 +477,8 @@ describe 'EPP Domain', epp: true do response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2004') - expect(response[:msg]).to eq('DNS keys count must be between 0-1') + response[:result_code].should == '2004' + response[:msg].should == 'DNS keys count must be between 0-1' end it 'creates domain with ds data' do @@ -497,14 +497,14 @@ describe 'EPP Domain', epp: true do d = Domain.last 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 + 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 with key' do @@ -529,14 +529,14 @@ describe 'EPP Domain', epp: true do d = Domain.last 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') + 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 'prohibits dsData with key' do @@ -560,8 +560,8 @@ describe 'EPP Domain', epp: true do }) 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') + response[:result_code].should == '2306' + response[:msg].should == 'dsData object with key data is not allowed' end it 'prohibits dsData' do @@ -585,8 +585,8 @@ describe 'EPP Domain', epp: true do }) response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2306') - expect(response[:msg]).to eq('dsData object is not allowed') + response[:result_code].should == '2306' + response[:msg].should == 'dsData object is not allowed' end it 'prohibits keyData' do @@ -603,8 +603,8 @@ describe 'EPP Domain', epp: true do }) response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2306') - expect(response[:msg]).to eq('keyData object is not allowed') + response[:result_code].should == '2306' + response[:msg].should == 'keyData object is not allowed' end end @@ -618,15 +618,15 @@ 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') - expect(response[:clTRID]).to eq('ABC-12345') + response[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' + response[:clTRID].should == 'ABC-12345' - expect(Domain.last.tech_contacts.count).to eq 1 - expect(Domain.last.admin_contacts.count).to eq 1 + Domain.last.tech_contacts.count.should == 1 + Domain.last.admin_contacts.count.should == 1 tech_contact = Domain.last.tech_contacts.first - expect(tech_contact.code).to eq('juridical_1234') + tech_contact.code.should == 'juridical_1234' end it 'does not create a domain without admin contact' do @@ -640,12 +640,12 @@ describe 'EPP Domain', epp: true do }) 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') + response[:result_code].should == '2004' + response[:msg].should == 'Admin contacts count must be between 1-10' + response[:clTRID].should == 'ABC-12345' - expect(Domain.count).to eq domain_count - expect(DomainContact.count).to eq domain_contact_count + Domain.count.should == domain_count + DomainContact.count.should == domain_contact_count end it 'cannot assign juridical person as admin contact' do @@ -657,8 +657,8 @@ describe 'EPP Domain', epp: true do }) response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2306') - expect(response[:msg]).to eq('Admin contact can be only citizen') + response[:result_code].should == '2306' + response[:msg].should == 'Admin contact can be only citizen' end end @@ -682,15 +682,15 @@ describe 'EPP Domain', epp: true do dtl = domain.domain_transfers.last trn_data = response[:parsed].css('trnData') - expect(trn_data.css('name').text).to eq(domain.name) - 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) + 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 - expect(domain.registrar).to eq(@elkdata) + domain.registrar.should == @elkdata Setting.transfer_wait_time = 1 @@ -707,57 +707,57 @@ describe 'EPP Domain', epp: true do domain.reload dtl = domain.domain_transfers.last - expect(domain.domain_transfers.count).to eq(2) + domain.domain_transfers.count.should == 2 - expect(trn_data.css('name').text).to eq(domain.name) - 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) + 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 - expect(domain.registrar).to eq(@elkdata) + domain.registrar.should == @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(domain.name) - 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) + 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 - expect(domain.registrar).to eq(@elkdata) + domain.registrar.should == @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') + response[:msg].should == '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') + 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 = epp_request(xml, :xml, :elkdata) - expect(response[:msg]).to eq('Command completed successfully') + response[:msg].should == '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') + msg_q.first['id'].should_not be_blank + msg_q.first['count'].should == '0' end it 'creates a domain transfer with legal document' do Setting.transfer_wait_time = 1 - expect(domain.legal_documents.count).to eq(0) + domain.legal_documents.count.should == 0 pw = domain.auth_info xml = domain_transfer_xml({ name: { value: domain.name }, @@ -773,35 +773,35 @@ describe 'EPP Domain', epp: true do response = epp_request(xml, :xml, :elkdata) - expect(response[:result_code]).to eq('1000') - expect(domain.legal_documents.count).to eq(1) + response[:result_code].should == '1000' + domain.legal_documents.count.should == 1 log = ApiLog::EppLog.last(4) - expect(log[0].request_command).to eq('hello') - expect(log[0].request_successful).to eq(true) + log[0].request_command.should == 'hello' + log[0].request_successful.should == 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') + 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' - 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 + log[2].request_command.should == 'transfer' + log[2].request_object.should == 'domain' + 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(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') + 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' 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 + response[:result_code].should == '1000' + domain.legal_documents.count.should == 1 # does not add another legal documen end it 'approves the transfer request' do @@ -822,12 +822,12 @@ describe 'EPP Domain', epp: true do trn_data = response[:parsed].css('trnData') - expect(trn_data.css('name').text).to eq(domain.name) - 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) + 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 @@ -852,14 +852,14 @@ describe 'EPP Domain', epp: true do }) response = epp_request(xml, :xml, :elkdata) - expect(response[:msg]).to eq('Transfer can be rejected only by current registrar') - expect(response[:result_code]).to eq('2304') - expect(domain.legal_documents.count).to eq(0) + response[:msg].should == 'Transfer can be rejected only by current registrar' + response[:result_code].should == '2304' + domain.legal_documents.count.should == 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) + 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 @@ -876,8 +876,8 @@ describe 'EPP Domain', epp: true do }, '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') + 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 @@ -886,8 +886,8 @@ describe 'EPP Domain', epp: true do authInfo: { pw: { value: 'test' } } }) response = epp_request(xml, :xml) - expect(response[:result_code]).to eq('2201') - expect(response[:msg]).to eq('Authorization error') + response[:result_code].should == '2201' + response[:msg].should == 'Authorization error' end it 'ignores transfer when owner registrar requests transfer' do @@ -898,14 +898,14 @@ describe 'EPP Domain', epp: true do }) 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') + 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_request(domain_transfer_xml({}, 'bla'), :xml, :zone) - expect(response[:result_code]).to eq('2306') - expect(response[:msg]).to eq('Attribute op is invalid') + response[:result_code].should == '2306' + response[:msg].should == 'Attribute op is invalid' end it 'creates new pw after successful transfer' do @@ -917,8 +917,8 @@ describe 'EPP Domain', epp: true do 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') + response[:result_code].should == '2201' + response[:msg].should == 'Authorization error' end ### UPDATE ### @@ -941,12 +941,12 @@ describe 'EPP Domain', epp: true do ] }), :xml) - expect(response[:results][0][:result_code]).to eq('1000') + response[:results][0][:result_code].should == '1000' d = Domain.last - expect(d.owner_contact_code).to eq('citizen_1234') - expect(d.auth_info).to eq(existing_pw) + d.owner_contact_code.should == 'citizen_1234' + d.auth_info.should == existing_pw end it 'updates domain and adds objects' do @@ -994,56 +994,56 @@ describe 'EPP Domain', epp: true do }) 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') + response[:results][0][:result_code].should == '2303' + response[:results][0][:msg].should == 'Contact was not found' Fabricate(:contact, code: 'mak21') response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('1000') + response[:results][0][:result_code].should == '1000' d = Domain.last new_ns_count = d.nameservers.where(hostname: ['ns1.example.com', 'ns2.example.com']).count - expect(new_ns_count).to eq(2) + new_ns_count.should == 2 new_contact = d.tech_contacts.find_by(code: 'mak21') - expect(new_contact).to be_truthy + new_contact.should 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') + d.domain_statuses.count.should == 2 + d.domain_statuses.first.description.should == 'Payment overdue.' + d.domain_statuses.first.value.should == 'clientHold' - expect(d.domain_statuses.last.value).to eq('clientUpdateProhibited') - expect(d.dnskeys.count).to eq(2) + d.domain_statuses.last.value.should == 'clientUpdateProhibited' + d.dnskeys.count.should == 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') + 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' - 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') + 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' - 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') + response[:results][2][:result_code].should == '2302' + response[:results][2][:msg].should == 'Contact already exists on this domain' + response[:results][2][:value].should == 'mak21' - expect(response[:results][3][:msg]).to eq('Status already exists on this domain') - expect(response[:results][3][:value]).to eq('clientHold') + response[:results][3][:msg].should == 'Status already exists on this domain' + response[:results][3][:value].should == 'clientHold' - expect(response[:results][4][:msg]).to eq('Status already exists on this domain') - expect(response[:results][4][:value]).to eq('clientUpdateProhibited') + response[:results][4][:msg].should == 'Status already exists on this domain' + response[:results][4][:value].should == 'clientUpdateProhibited' - expect(response[:results][5][:msg]).to eq('Public key already exists') - expect(response[:results][5][:value]).to eq('700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f') + response[:results][5][:msg].should == 'Public key already exists' + response[:results][5][:value].should == '700b97b591ed27ec2590d19f06f88bba700b97b591ed27ec2590d19f' - expect(response[:results][6][:msg]).to eq('Public key already exists') - expect(response[:results][6][:value]).to eq('841936717ae427ace63c28d04918569a841936717ae427ace63c28d0') + response[:results][6][:msg].should == 'Public key already exists' + response[:results][6][:value].should == '841936717ae427ace63c28d04918569a841936717ae427ace63c28d0' - expect(d.domain_statuses.count).to eq(2) + d.domain_statuses.count.should == 2 end it 'updates a domain and removes objects' do @@ -1092,7 +1092,7 @@ describe 'EPP Domain', epp: true do epp_request(xml, :xml) d = Domain.last - expect(d.dnskeys.count).to eq(2) + d.dnskeys.count.should == 2 xml = domain_update_xml({ name: { value: domain.name }, @@ -1122,29 +1122,29 @@ describe 'EPP Domain', epp: true do epp_request(xml, :xml) - expect(d.dnskeys.count).to eq(1) + d.dnskeys.count.should == 1 - expect(d.domain_statuses.count).to eq(1) - expect(d.domain_statuses.first.value).to eq('clientUpdateProhibited') + d.domain_statuses.count.should == 1 + d.domain_statuses.first.value.should == 'clientUpdateProhibited' rem_ns = d.nameservers.find_by(hostname: 'ns1.example.com') - expect(rem_ns).to be_falsey + rem_ns.should be_falsey rem_cnt = d.tech_contacts.find_by(code: 'citizen_1234') - expect(rem_cnt).to be_falsey + rem_cnt.should 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('citizen_1234') + response[:results][0][:result_code].should == '2303' + response[:results][0][:msg].should == 'Contact was not found' + response[:results][0][:value].should == 'citizen_1234' - 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') + response[:results][1][:result_code].should == '2303' + response[:results][1][:msg].should == 'Nameserver was not found' + response[:results][1][:value].should == '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') + 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 @@ -1162,9 +1162,9 @@ describe 'EPP Domain', epp: true do 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') + 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 @@ -1191,13 +1191,13 @@ describe 'EPP Domain', epp: true do epp_request(xml, :xml) 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(n.hostname) + 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 - 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) + 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 @@ -1209,8 +1209,8 @@ describe 'EPP Domain', epp: true do } 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') + 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 @@ -1222,9 +1222,9 @@ describe 'EPP Domain', epp: true do }) 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') + response[:results][0][:result_code].should == '2303' + response[:results][0][:msg].should == 'Status was not found' + response[:results][0][:value].should == 'invalidStatus' end ### RENEW ### @@ -1239,8 +1239,8 @@ describe 'EPP Domain', epp: true do 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(domain.name) + 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 @@ -1251,8 +1251,8 @@ describe 'EPP Domain', epp: true do ) 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') + 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 @@ -1265,9 +1265,9 @@ describe 'EPP Domain', epp: true do ) 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') + 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 ### @@ -1302,79 +1302,79 @@ describe 'EPP Domain', epp: true do xml = domain_info_xml(name: { value: domain.name }) response = epp_request(xml, :xml) - expect(response[:results][0][:result_code]).to eq('1000') - expect(response[:results][0][:msg]).to eq('Command completed successfully') + response[:results][0][:result_code].should == '1000' + response[:results][0][:msg].should == 'Command completed successfully' inf_data = response[:parsed].css('resData infData') - expect(inf_data.css('name').text).to eq(domain.name) - 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(domain.owner_contact_code) + 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) - expect(admin_contacts_from_request).to eq(admin_contacts_existing) + admin_contacts_from_request.should == admin_contacts_existing hosts_from_request = inf_data.css('hostName').map(&:text) hosts_existing = domain.nameservers.pluck(:hostname) - expect(hosts_from_request).to eq(hosts_existing) + hosts_from_request.should == 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(domain.created_at.to_time.utc.to_s) - expect(inf_data.css('exDate').text).to eq(domain.valid_to.to_time.utc.to_s) - expect(inf_data.css('pw').text).to eq(domain.auth_info) + 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] - 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') + 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] - 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') + 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] - 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') + 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_request(domain_info_xml(name: { value: domain.name }), :xml) inf_data = response[:parsed].css('resData infData') - expect(inf_data.css('upDate').text).to eq(domain.updated_at.to_time.utc.to_s) + 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_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') + 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_request(domain_info_xml(name: { value: domain.name }), :xml) inf_data = response[:parsed].css('resData infData') - expect(inf_data.css('status').first[:s]).to eq('ok') + inf_data.css('status').first[:s].should == 'ok' end it 'can not see other registrar domains' do response = epp_request(domain_info_xml(name: { value: domain.name }), :xml, :elkdata) - expect(response[:result_code]).to eq('2302') - expect(response[:msg]).to eq('Domain exists but belongs to other registrar') + response[:result_code].should == '2302' + response[:msg].should == 'Domain exists but belongs to other registrar' end ### DELETE ### @@ -1390,9 +1390,9 @@ describe 'EPP Domain', epp: true do ] }), :xml) - expect(response[:result_code]).to eq('1000') + response[:result_code].should == '1000' - expect(Domain.find_by(name: domain.name)).to eq(nil) + Domain.find_by(name: domain.name).should == nil end it 'does not delete domain with specific status' do @@ -1409,14 +1409,14 @@ describe 'EPP Domain', epp: true do ] }), :xml) - expect(response[:result_code]).to eq('2304') - expect(response[:msg]).to eq('Domain status prohibits operation') + response[:result_code].should == '2304' + response[:msg].should == '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') + response[:result_code].should == '2003' + response[:msg].should == 'Required parameter missing: extension > extdata > legalDocument' end ### CHECK ### @@ -1427,12 +1427,12 @@ describe 'EPP Domain', epp: true do ] }), :xml) - expect(response[:result_code]).to eq('1000') - expect(response[:msg]).to eq('Command completed successfully') + response[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' res_data = response[:parsed].css('resData chkData cd name').first - expect(res_data.text).to eq('one.ee') - expect(res_data[:avail]).to eq('1') + res_data.text.should == 'one.ee' + res_data[:avail].should == '1' response = epp_request(domain_check_xml({ _anonymus: [ @@ -1443,9 +1443,9 @@ describe 'EPP Domain', epp: true do name = res_data.css('name').first reason = res_data.css('reason').first - expect(name.text).to eq(domain.name) - 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 @@ -1458,16 +1458,16 @@ 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[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' res_data = response[:parsed].css('resData chkData cd name').first - expect(res_data.text).to eq('one.ee') - expect(res_data[:avail]).to eq('1') + res_data.text.should == 'one.ee' + res_data[:avail].should == '1' res_data = response[:parsed].css('resData chkData cd name').last - expect(res_data.text).to eq('three.ee') - expect(res_data[:avail]).to eq('1') + res_data.text.should == 'three.ee' + res_data[:avail].should == '1' end it 'checks invalid format domain' do @@ -1479,20 +1479,20 @@ 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[:result_code].should == '1000' + response[:msg].should == 'Command completed successfully' res_data = response[:parsed].css('resData chkData cd name').first - expect(res_data.text).to eq('one.ee') - expect(res_data[:avail]).to eq('1') + res_data.text.should == 'one.ee' + res_data[:avail].should == '1' 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