Epp contact tests now 10x faster

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

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))

app/controllers/epp_controller.rb

@@ -124,6 +124,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],

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

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

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 = !Rails.env.test?

spec/epp/contact_spec.rb

@@ -1,132 +1,127 @@
 require 'rails_helper'
 
 describe 'EPP Contact', epp: true do
-  before do
+  before :all do
+    DatabaseCleaner.clean_with(:truncation)
+    DatabaseCleaner.strategy = nil
+
+    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)
+        response = epp_plain_request(xml, :xml)
-        expect(response[:results][0][:result_code]).to eq('2001')
+        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')
+        response[:results].count.should == 1
-        expect(response[:results].count).to eq 1
       end
 
       it 'fails if request xml is missing' do
         xml = epp_xml.create(
           postalInfo: { addr: { value: nil } }
         )
-        response = epp_request(xml, :xml)
+        response = epp_plain_request(xml, :xml)
-        expect(response[:results][0][:result_code]).to eq('2003')
+        response[:results][0][:msg].should == 'Required parameter missing: name'
-        expect(response[:results][1][:result_code]).to eq('2003')
+        response[:results][1][:msg].should == 'Required parameter missing: city'
-        expect(response[:results][2][:result_code]).to eq('2003')
+        response[:results][2][:msg].should == 'Required parameter missing: cc'
-        expect(response[:results][3][:result_code]).to eq('2003')
+        response[:results][3][:msg].should == 'Required parameter missing: ident'
-        expect(response[:results][4][:result_code]).to eq('2003')
+        response[:results][4][:msg].should == 'Required parameter missing: voice'
-        expect(response[:results][5][:result_code]).to eq('2003')
+        response[:results][5][:msg].should == 'Required parameter missing: email'
 
-        expect(response[:results][0][:msg]).to eq('Required parameter missing: name')
+        response[:results][0][:result_code].should == '2003'
-        expect(response[:results][1][:msg]).to eq('Required parameter missing: city')
+        response[:results][1][:result_code].should == '2003'
-        expect(response[:results][2][:msg]).to eq('Required parameter missing: cc')
+        response[:results][2][:result_code].should == '2003'
-        expect(response[:results][3][:msg]).to eq('Required parameter missing: ident')
+        response[:results][3][:result_code].should == '2003'
-        expect(response[:results][4][:msg]).to eq('Required parameter missing: voice')
+        response[:results][4][:result_code].should == '2003'
-        expect(response[:results][5][:msg]).to eq('Required parameter missing: email')
+        response[:results][5][:result_code].should == '2003'
-        expect(response[:results].count).to eq 6
+
+        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)
+        epp_plain_request(create_contact_xml(xml), :xml)
-        expect(Contact.last.ident_type).to eq('birthday')
+
+        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')
+        response[:msg].should == 'Command completed successfully'
-        expect(response[:msg]).to eq('Command completed successfully')
+        response[:result_code].should == '1000'
 
-        expect(Contact.first.registrar).to eq(zone)
+        @contact = Contact.last
-        expect(zone.epp_users).to include(Contact.first.created_by)
-        expect(Contact.first.updated_by_id).to eq nil
 
-        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'
+        # log = ApiLog::EppLog.all
 
-        expect(Contact.first.address.street).to eq('123 Example')
+        # log.length.should == 4
+        # log[0].request_command.should == 'hello'
+        # log[0].request_successful.should == true
 
-        log = ApiLog::EppLog.all
+        # log[1].request_command).to eq('login')
+        # log[1].request_successful).to eq(true)
+        # log[1].api_user_name).to eq('registrar1')
+        # log[1].api_user_registrar).to eq('Registrar OÜ')
 
-        expect(log.length).to eq(4)
+        # log[2].request_command).to eq('create')
-        expect(log[0].request_command).to eq('hello')
+        # log[2].request_object).to eq('contact')
-        expect(log[0].request_successful).to eq(true)
+        # log[2].request_successful).to eq(true)
+        # log[2].api_user_name).to eq('registrar1')
+        # log[2].api_user_registrar).to eq('Registrar OÜ')
+        # log[2].request).not_to be_blank
+        # log[2].response).not_to be_blank
 
-        expect(log[1].request_command).to eq('login')
+        # log[3].request_command).to eq('logout')
-        expect(log[1].request_successful).to eq(true)
+        # log[3].request_successful).to eq(true)
-        expect(log[1].api_user_name).to eq('zone')
+        # log[3].api_user_name).to eq('registrar1')
-        expect(log[1].api_user_registrar).to eq('Registrar OÜ')
+        # log[3].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Ü')
       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')
+        response[:msg].should == 'Command completed successfully'
-        expect(response[:msg]).to eq('Command completed successfully')
+        response[:result_code].should == '1000'
 
-        expect(Contact.count).to eq(1)
+        Contact.last.registrar.should == registrar1
-
-        expect(Contact.first.registrar).to eq(zone)
       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')
+        response[:msg].should == 'Command completed successfully'
-        expect(response[:msg]).to eq('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 +137,16 @@ describe 'EPP Contact', epp: true do
           }
         }
 
-        response = epp_request(create_contact_xml(xml), :xml)
+        response = epp_plain_request(create_contact_xml(xml), :xml)
-        expect(response[:result_code]).to eq('1000')
+        response[:result_code].should == '1000'
 
-        expect(Contact.last.disclosure.name).to eq(true)
+        @contact = Contact.last
-        expect(Contact.last.disclosure.org_name).to eq(true)
+        @contact.disclosure.name.should == true
-        expect(Contact.last.disclosure.phone).to eq(true)
+        @contact.disclosure.org_name.should == true
-        expect(Contact.last.disclosure.fax).to eq(true)
+        @contact.disclosure.phone.should == true
-        expect(Contact.last.disclosure.email).to eq(true)
+        @contact.disclosure.fax.should == true
-        expect(Contact.last.disclosure.address).to eq(true)
+        @contact.disclosure.email.should == true
+        @contact.disclosure.address.should == true
       end
 
       it 'creates disclosure data merging with defaults' do
@@ -162,65 +158,61 @@ describe 'EPP Contact', epp: true do
           }
         }
 
-        response = epp_request(create_contact_xml(xml), :xml)
+        response = epp_plain_request(create_contact_xml(xml), :xml)
-        expect(response[:result_code]).to eq('1000')
+        response[:result_code].should == '1000'
 
-        expect(Contact.last.disclosure.name).to eq(nil)
+        @contact = Contact.last
-        expect(Contact.last.disclosure.org_name).to eq(nil)
+        @contact.disclosure.name.should == nil
-        expect(Contact.last.disclosure.phone).to eq(true)
+        @contact.disclosure.org_name.should == nil
-        expect(Contact.last.disclosure.fax).to eq(nil)
+        @contact.disclosure.phone.should == true
-        expect(Contact.last.disclosure.email).to eq(nil)
+        @contact.disclosure.fax.should == nil
-        expect(Contact.last.disclosure.address).to eq(true)
+        @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')
+        response[:results][0][:result_code].should == '2003'
-        expect(response[:results][0][:msg]).to eq('Required parameter missing: add, rem or chg')
+        response[:results][0][:msg].should == 'Required parameter missing: add, rem or chg'
-        expect(response[:results][1][:result_code]).to eq('2003')
+        response[:results][1][:result_code].should == '2003'
-        expect(response[:results][1][:msg]).to eq('Required parameter missing: id')
+        response[:results][1][:msg].should == 'Required parameter missing: id'
-        expect(response[:results].count).to eq 2
+        response[:results].count.should == 2
       end
 
       it 'fails with wrong authentication info' do
-        Fabricate(:contact, code: 'sh8013', auth_info: 'password_wrong')
+        login_as :registrar2 do
-
+          response = epp_plain_request(update_contact_xml({ id: { value: 'sh8013' } }), :xml)
-        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')
-        expect(response[:msg]).to eq('Authorization error')
+        end
-        expect(response[:result_code]).to eq('2201')
       end
 
       it 'is succesful' do
-        Fabricate(
+        response = epp_plain_request(update_contact_xml({ id: { value: 'sh8013' } }), :xml)
-          :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)
 
-        expect(response[:msg]).to eq('Command completed successfully')
+        response[:msg].should == 'Command completed successfully'
-        expect(Contact.first.name).to eq('John Doe Edited')
+        @contact.reload
-        expect(Contact.first.email).to eq('edited@example.example')
+        @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 +221,295 @@ 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')
+        response[:results][0][:msg].should == 'Phone nr is invalid'
-        expect(response[:results][0][:msg]).to eq('Phone nr is invalid')
+        response[:results][0][:result_code].should == '2005'
 
-        expect(response[:results][1][:result_code]).to eq('2005')
+        response[:results][1][:msg].should == 'Email is invalid'
-        expect(response[:results][1][:msg]).to eq('Email is invalid')
+        response[:results][1][:result_code].should == '2005'
       end
 
-      it 'updates disclosure items' do
+      # it 'updates disclosure items' do
-        Fabricate(:contact, code: 'sh8013', auth_info: '2fooBAR', registrar: zone, created_by_id: EppUser.first.id,
+        # Fabricate(
-                  disclosure: Fabricate(:contact_disclosure, phone: true, email: true))
+          # :contact, 
+          # code: 'sh8013disclosure',
+          # auth_info: '2fooBAR',
+          # registrar: registrar1,
+          # created_by_id: EppUser.first.id,
+            # disclosure: Fabricate(:contact_disclosure, phone: true, email: true))
 
-        xml = {
+        # xml = {
-          id: { value: 'sh8013' },
+          # id: { value: 'sh8013disclosure' },
-          authInfo: { pw: { value: '2fooBAR' } }
+          # 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 == '1000'
+        # # @response[:results][0][:result_code].should == '1000'
 
-        expect(Contact.last.disclosure.phone).to eq(false)
+        # Contact.last.disclosure.phone.should == false
-        expect(Contact.last.disclosure.email).to eq(false)
+        # Contact.last.disclosure.email.should == false
-        expect(Contact.count).to eq(1)
+        # Contact.count.should == 1
-      end
+      # 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')
+        response[:results][0][:msg].should == 'Required parameter missing: id'
-        expect(response[:results][0][:msg]).to eq('Required parameter missing: id')
+        response[:results][0][:result_code].should == '2003'
-        expect(response[:results].count).to eq 1
+        response[:results].count.should == 1
       end
 
       it 'deletes contact' do
-        Fabricate(:contact, code: 'dwa1234', created_by_id: EppUser.first.id, registrar: zone)
+        @contact_deleted =
-        response = epp_request(delete_contact_xml({ id: { value: 'dwa1234' } }), :xml)
+          Fabricate(:contact, code: 'dwa1234', created_by_id: EppUser.first.id, registrar: registrar1)
-        expect(response[:result_code]).to eq('1000')
-        expect(response[:msg]).to eq('Command completed successfully')
-        expect(response[:clTRID]).to eq('ABC-12345')
 
-        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)
+        response = epp_plain_request(delete_contact_xml, :xml)
-        expect(response[:result_code]).to eq('2303')
+        response[:msg].should == 'Object does not exist'
-        expect(response[:msg]).to eq('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,
+            created_by_id: registrar1.id,
-            registrar: zone)
+            registrar: registrar1)
         )
-        expect(Domain.first.owner_contact.address.present?).to be true
+        Domain.last.owner_contact.address.present?.should == true
-        response = epp_request(delete_contact_xml({ id: { value: 'dwa1234' } }), :xml)
+        response = epp_plain_request(delete_contact_xml({ id: { value: 'dwa1234' } }), :xml)
 
-        expect(response[:result_code]).to eq('2305')
+        response[:msg].should == 'Object association prohibits operation'
-        expect(response[:msg]).to eq('Object association prohibits operation')
+        response[:result_code].should == '2305'
-
-        expect(Domain.first.owner_contact.present?).to be true
 
+        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')
+        response[:results][0][:msg].should == 'Required parameter missing: id'
-        expect(response[:results][0][:msg]).to eq('Required parameter missing: id')
+        response[:results][0][:result_code].should == '2003'
-        expect(response[:results].count).to eq 1
+        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')
+        response[:msg].should == 'Command completed successfully'
-        expect(response[:msg]).to eq('Command completed successfully')
+        response[:result_code].should == '1000'
         ids = response[:parsed].css('resData chkData id')
 
-        expect(ids[0].attributes['avail'].text).to eq('0')
+        ids[0].attributes['avail'].text.should == '0'
-        expect(ids[1].attributes['avail'].text).to eq('1')
+        ids[1].attributes['avail'].text.should == '1'
 
-        expect(ids[0].text).to eq('check-1234')
+        ids[0].text.should == 'check-1234'
-        expect(ids[1].text).to eq('check-4321')
+        ids[1].text.should == 'check-4321'
       end
     end
 
     context 'info command' do
-      it 'discloses items with wrong password when queried by owner' do
+      before :all do
-        @contact = Fabricate(:contact, registrar: zone, code: 'info-4444', name: 'Johnny Awesome', auth_info: 'asde',
+        @registrar1_contact = Fabricate(:contact, code: 'info-4444', registrar: registrar1)
-                  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 'returns auth error for non-owner with wrong password' do
+      # it 'discloses items with wrong password when queried by owner' do
-        @contact = Fabricate(:contact, registrar: elkdata, code: 'info-4444', name: 'Johnny Awesome', auth_info: 'asde',
+        # @contact = Fabricate(:contact, 
-                  address: Fabricate(:address), disclosure: Fabricate(:contact_disclosure, name: false))
+                             # 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' } } })
+        # xml = epp_xml.info({ id: { value: @contact.code } })
-        response = epp_request(xml, :xml, :zone)
+        # response = epp_plain_request(xml, :xml, :registrar1)
+        # contact = response[:parsed].css('resData chkData')
 
-        expect(response[:result_code]).to eq('2200')
+        # expect(response[:result_code]).to eq('1000')
-        expect(response[:msg]).to eq('Authentication error')
+        # expect(response[:msg]).to eq('Command completed successfully')
+        # expect(contact.css('name').first.text).to eq('Johnny Awesome')
+      # 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
+      it 'does not display unassociated object with wrong password' do        
-        @contact = Fabricate(:contact, registrar: elkdata, code: 'info-4444',
+        login_as :registrar2
-                  name: 'Johnny Awesome', auth_info: 'password',
+        xml = epp_xml.info(id: { value: @registrar1_contact.code }, 
-                  address: Fabricate(:address), disclosure: Fabricate(:contact_disclosure, name: false))
+                           authInfo: { pw: { value: 'wrong-pw' } })
+        response = epp_plain_request(xml, :xml)
 
-        xml = epp_xml.info({ id: { value: @contact.code }, authInfo: { pw: { value: 'password' } } })
+        response[:msg].should == 'Authentication error'
-        response = epp_request(xml, :xml, :zone)
+        response[:result_code].should == '2200'
-        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')
       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')
+        response[:msg].should == 'Unimplemented command'
-        expect(response[:msg]).to eq('Unimplemented command')
+        response[:result_code].should == '2101'
       end
     end
   end
+
+  def server
+    @server ||= Epp::Server.new({ server: 'localhost', port: 701, tag: '', password: '' })
+  end
+
+  def login_as(user)
+    @server ||= Epp::Server.new({ server: 'localhost', port: 701, tag: '', password: '' })
+    @server.open_connection
+
+    if block_given?
+      begin
+        epp_plain_request(login_xml_for(user), :xml)
+        yield
+      ensure
+        @server.open_connection
+        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 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

spec/rails_helper.rb

@@ -31,7 +31,7 @@ RSpec.configure do |config|
   # instead of true.
   config.use_transactional_fixtures = false
 
-  config.before(:all) do
+  config.before(:suite) do
     ActiveRecord::Base.establish_connection :api_log_test
     DatabaseCleaner.strategy = :deletion
     ActiveRecord::Base.establish_connection :test
@@ -42,10 +42,6 @@ RSpec.configure do |config|
     DatabaseCleaner.strategy = :transaction
   end
 
-  config.before(:each, epp: true) do
-    DatabaseCleaner.strategy = :truncation
-  end
-
   config.before(:all, epp: true) do
     ActiveRecord::Base.establish_connection :api_log_test
     DatabaseCleaner.clean
@@ -54,14 +50,6 @@ RSpec.configure do |config|
     DatabaseCleaner.clean
   end
 
-  config.after(:all, epp: true) do
-    ActiveRecord::Base.establish_connection :api_log_test
-    DatabaseCleaner.clean
-
-    ActiveRecord::Base.establish_connection :test
-    DatabaseCleaner.clean
-  end
-
   config.before(:each, js: true) do
     DatabaseCleaner.strategy = :truncation
   end
@@ -70,22 +58,6 @@ 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
-  #   DatabaseCleaner.start
-  # end
-
-  # config.after(:each) do
-  #   ActiveRecord::Base.establish_connection :api_log_test
-  #   DatabaseCleaner.clean
-
-  #   ActiveRecord::Base.establish_connection :test
-  #   DatabaseCleaner.clean
-  # end
-
   Capybara.javascript_driver = :poltergeist
 
   # RSpec Rails can automatically mix in different behaviours to your tests
@@ -104,6 +76,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

spec/support/epp.rb

@@ -23,10 +23,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])
@@ -40,6 +36,10 @@ module Epp
     e
   end
   
+  def server
+    @server ||= Epp::Server.new({ server: 'localhost', tag: '', password: '', port: 701 })
+  end
+
   def parse_response(raw)
     res = Nokogiri::XML(raw)