diff --git a/spec/epp/poll_spec.rb b/spec/epp/poll_spec.rb
index 060d1e47e..a22659887 100644
--- a/spec/epp/poll_spec.rb
+++ b/spec/epp/poll_spec.rb
@@ -3,157 +3,157 @@ 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 }
 
-  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 'returns no messages in poll' do
-      response = epp_request(epp_xml.poll, :xml)
+    @uniq_no = proc { @i ||= 0; @i += 1 }
+  end
 
-      expect(response[:msg]).to eq('Command completed successfully; no messages')
-      expect(response[:result_code]).to eq('1300')
+  it 'returns no messages in poll' do
+    response = epp_request(epp_xml.poll, :xml)
 
-      log = ApiLog::EppLog.all
+    expect(response[:msg]).to eq('Command completed successfully; no messages')
+    expect(response[:result_code]).to eq('1300')
 
-      expect(log.length).to eq(4)
-      expect(log[0].request_command).to eq('hello')
-      expect(log[0].request_successful).to eq(true)
+    log = ApiLog::EppLog.all
 
-      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.length).to eq(4)
+    expect(log[0].request_command).to eq('hello')
+    expect(log[0].request_successful).to eq(true)
 
-      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[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[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
+    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
 
-    it 'queues and dequeues messages' do
-      msg = zone.messages.create({ body: 'Balance low.' })
+    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
 
-      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')
+  it 'queues and dequeues messages' do
+    msg = @zone.messages.create({ body: 'Balance low.' })
 
-      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_request(epp_xml.poll, :xml, :elkdata)
+    expect(response[:msg]).to eq('Command completed successfully; no messages')
+    expect(response[:result_code]).to eq('1300')
 
-      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)
+    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')
 
-      xml = epp_xml.poll(poll: {
-        value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] }
-      })
+    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)
 
-      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'])
+    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(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'])
 
-      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
+    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')
 
-    it 'returns an error on incorrect op' do
-      xml = epp_xml.poll(poll: {
-        value: '', attrs: { op: 'bla' }
-      })
+    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
 
-      response = epp_request(xml, :xml, :zone)
-      expect(response[:msg]).to eq('Attribute op is invalid')
-    end
+  it 'returns an error on incorrect op' do
+    xml = epp_xml.poll(poll: {
+      value: '', attrs: { op: 'bla' }
+    })
 
-    it 'dequeues multiple messages' do
-      zone.messages.create({ body: 'Balance low.' })
-      zone.messages.create({ body: 'Something.' })
-      zone.messages.create({ body: 'Smth else.' })
+    response = epp_request(xml, :xml, :zone)
+    expect(response[:msg]).to eq('Attribute op is invalid')
+  end
 
-      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')
+  it 'dequeues multiple messages' do
+    @zone.messages.create({ body: 'Balance low.' })
+    @zone.messages.create({ body: 'Something.' })
+    @zone.messages.create({ body: 'Smth else.' })
 
-      expect(msg_q.css('msg').text).to eq('Smth else.')
-      expect(msg_q.first['count']).to eq('3')
+    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')
 
-      xml = epp_xml.poll(poll: {
-        value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] }
-      })
+    expect(msg_q.css('msg').text).to eq('Smth else.')
+    expect(msg_q.first['count']).to eq('3')
 
-      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')
+    xml = epp_xml.poll(poll: {
+      value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] }
+    })
 
-      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_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')
 
-      expect(msg_q.css('msg').text).to eq('Something.')
-      expect(msg_q.first['count']).to eq('2')
+    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')
 
-      xml = epp_xml.poll(poll: {
-        value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] }
-      })
+    expect(msg_q.css('msg').text).to eq('Something.')
+    expect(msg_q.first['count']).to eq('2')
 
-      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')
+    xml = epp_xml.poll(poll: {
+      value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] }
+    })
 
-      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_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')
 
-      expect(msg_q.css('msg').text).to eq('Balance low.')
-      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')
 
-      xml = epp_xml.poll(poll: {
-        value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] }
-      })
+    expect(msg_q.css('msg').text).to eq('Balance low.')
+    expect(msg_q.first['count']).to eq('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('0')
+    xml = epp_xml.poll(poll: {
+      value: '', attrs: { op: 'ack', msgID: msg_q.first['id'] }
+    })
 
-      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_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
 end