espago 0.1.8 → 0.1.9

data/lib/espago/api_connection/tokens_post.rb

@@ -3,7 +3,7 @@ module Espago
     class TokensPost < ApiPost
       def initialize(connection)
         @connection = connection
-        @connection.basic_auth(Espago.public_key, '')
+        @connection.request(:authorization, :basic, Espago.public_key, '')
       end
 
       def request(params = {})

data/lib/espago/api_connection/visacheckout_post.rb

@@ -0,0 +1,9 @@
+module Espago
+  class ApiConnection
+    class VisacheckoutPost < ApiPost
+      def request(params = {})
+        super("visacheckout", params)
+      end
+    end
+  end
+end

data/lib/espago/api_connection.rb

@@ -22,8 +22,6 @@ end
 
 module Espago
   class ApiConnection
-    extend Forwardable
-    def_delegator :@connection, :basic_auth, :authenticate
 
     def initialize(enviroment,headers)
       @connection = Faraday.new(enviroment)
@@ -38,6 +36,10 @@ module Espago
       handle_response response
     end
 
+    def authenticate(username, password)
+      @connection.request(:authorization, :basic, username, password)
+    end
+
     private
 
     def handle_response(response)

data/lib/espago/client.rb

@@ -12,13 +12,13 @@ module Espago
     end
 
     def send_request(path, method, params = {})
-      
+
       app_id = params[:app_id].present? ?  params.delete(:app_id) : @app_id
-      app_password = params[:app_password].present? ? params.delete(:app_password) : @app_password 
-      production_param = !params[:production].nil? ? params.delete(:production) : production 
-      
+      app_password = params[:app_password].present? ? params.delete(:app_password) : @app_password
+      production_param = !params[:production].nil? ? params.delete(:production) : production
+
       raise NotAuthenticated unless valid?(app_id, app_password)
-      
+
       connection = @connection.new(enviroment(production_param),api_version_header)
       connection.authenticate(app_id, app_password)
       connection.create(path, method, params)
@@ -30,7 +30,6 @@ module Espago
 
     private
     def enviroment(production_param)
-      # "http://127.0.0.1:3007/api"
       production_param ? "https://secure.espago.com/api" : "https://sandbox.espago.com/api"
     end
 

data/lib/espago/secure_web_page.rb

@@ -1,28 +1,31 @@
-require "forwardable"
+# frozen_string_literal: true
+
+require 'forwardable'
 module Espago
   class SecureWebPage
     attr_accessor :production
 
-    def self.calculate_checksum(app_id, kind, session_id,amount,currency,ts,checksum_key)
-      Digest::MD5.hexdigest(
+    def self.calculate_checksum(app_id, kind, session_id, amount, currency, ts, service_client_id, checksum_key)
+      return Digest::MD5.hexdigest(
         [app_id.to_s, kind, session_id.to_s, amount.to_s, currency.to_s, ts.to_s, checksum_key.to_s].join('|')
+      ) if service_client_id.blank?
+      Digest::MD5.hexdigest(
+        [app_id.to_s, kind, session_id.to_s, amount.to_s, currency.to_s, ts.to_s, service_client_id.to_s, checksum_key.to_s].join('|')
       )
     end
 
-    def self.form_post(api_v=nil)
-      Espago.production ? "https://secure.espago.com/secure_web_page" : "https://sandbox.espago.com/secure_web_page"
+    def self.form_post(_api_v = nil)
+      Espago.production ? 'https://secure.espago.com/secure_web_page' : 'https://sandbox.espago.com/secure_web_page'
     end
 
     def self.prepare_form(data)
-      data[:kind] ||=  'sale'
-      data[:ts] ||=  Time.now.to_i
+      data[:kind] ||= 'sale'
+      data[:ts] ||= Time.now.to_i
       data[:app_id] ||=  Espago.app_id
       data[:api_version] ||= Espago.api_version
       data[:amount] = format('%.2f', data[:amount])
-      data[:checksum] = calculate_checksum(data[:app_id],data[:kind],data[:session_id],data[:amount],data[:currency],data[:ts],data[:checksum_key]|| Espago.checksum_key)
+      data[:checksum] = calculate_checksum(data[:app_id], data[:kind], data[:session_id], data[:amount], data[:currency], data[:ts], data[:service_client_id], data[:checksum_key] || Espago.checksum_key)
       data
     end
-
-
   end
 end

data/lib/espago/version.rb

@@ -1,3 +1,3 @@
 module Espago
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

data/spec/espago/api_connection_spec.rb

@@ -27,7 +27,7 @@ describe Espago::ApiConnection do
 
   context "#create" do
     it "returns response" do
-      subject.create(:path, :stubbed).should be_a_kind_of Espago::Response
+      expect(subject.create(:path, :stubbed)).to be_a_kind_of Espago::Response
     end
     it "raises auth error" do
       expect { subject.create(:path, :unauthorized) }.to raise_error Espago::AuthenticationError

data/spec/espago/back_request_spec.rb

@@ -19,15 +19,15 @@ describe Espago::BackRequest do
      "created_at"=>1417030497
      }
   }
-
-  its(:id) { should eq("in_tUCMhwlg2nkvAaL") }
-  its(:subscription) { should eq("sub_8yYuCBKdywr7e2") }
-  its(:amount) { should eq("123.45") }
-  its(:currency) { should eq("pln") }
-  its(:paid) { should eq("true") }
-  its(:client) { should eq("cli_90Pi6Jf0ndl_PP") }
-  its(:created_at) { should eq(Time.at(1417030497)) }
-  its(:card) { should eq({}) }
-  its(:imaginated_attribute) { should be_nil }
-
+  it {
+    expect(subject.id).to eq("in_tUCMhwlg2nkvAaL")
+    expect(subject.subscription).to eq("sub_8yYuCBKdywr7e2")
+    expect(subject.amount).to eq("123.45")
+    expect(subject.currency).to eq("pln")
+    expect(subject.paid).to eq("true")
+    expect(subject.client).to eq("cli_90Pi6Jf0ndl_PP")
+    expect(subject.created_at).to eq(Time.at(1417030497))
+    expect(subject.card).to eq({})
+    expect(subject.imaginated_attribute).to be_nil
+  }
 end

data/spec/espago/client_spec.rb

@@ -15,10 +15,10 @@ describe Espago::Client do
   let(:stubbed_api_connection) { StubbedApiConnection }
   let(:response) { FakeResponse.new(200, {id: 1, status: "2012"}.to_json) }
 
-  it { subject.should respond_to :app_id }
-  it { subject.should respond_to :app_password }
-  it { subject.should respond_to :public_key }
-  it { subject.should respond_to :api_version }
+  it { expect(subject).to respond_to :app_id }
+  it { expect(subject).to respond_to :app_password }
+  it { expect(subject).to respond_to :public_key }
+  it { expect(subject).to respond_to :api_version }
 
   context "#send_request" do
     let(:method) { :get }
@@ -26,7 +26,7 @@ describe Espago::Client do
     let(:params) { { name: "Jan Kowalski"} }
 
     it "should create an api request" do
-      subject.send_request(path, method, params).should eq('returned api data')
+      expect(subject.send_request(path, method, params)).to eq('returned api data')
     end
 
     context "with no credentials" do
@@ -45,7 +45,7 @@ describe Espago::Client do
     let(:params) { { name: "Jan Kowalski", app_id: 'app_id_test', app_password: 'secret'} }
 
     it "should create an api request" do
-      subject.send_request(path, method, params).should eq('returned api data')
+      expect(subject.send_request(path, method, params)).to eq('returned api data')
     end
 
   end
@@ -54,12 +54,12 @@ describe Espago::Client do
     subject { Espago::Client.new }
 
     it "should delegate work to parser" do
-      Espago::Response.should_receive(:new).with(response)
+      expect(Espago::Response).to receive(:new).with(response)
       subject.parse_response(response)
     end
 
     it "should parse response into object" do
-      subject.parse_response(response).class.should eq(Espago::Response)
+      expect(subject.parse_response(response).class).to eq(Espago::Response)
     end
   end
 

data/spec/espago/error_spec.rb

@@ -10,7 +10,8 @@ describe Espago::Error do
   let(:response) {
     FakeResponse.new(422, response_body)
   }
-
-  its(:body) { should eq('body') }
-  its(:status) { should eq(422) }
+  it {
+    expect(subject.body).to eq('body')
+    expect(subject.status).to eq(422)
+  }
 end

data/spec/espago/response_spec.rb

@@ -25,14 +25,14 @@ describe Espago::Response do
       }
     }.to_json)
   }
-
-  its(:id) { should eq("pay_hViT20SOWaUL_w") }
-  its(:description) { should eq("Zakupy z example.com") }
-  its(:amount) { should eq("49.99") }
-  its(:currency) { should eq("pln") }
-  its(:state) { should eq("executed") }
-  its(:client) { should eq("cli_wm7dGQltAqIfH8") }
-  its(:created_at) { should eq(Time.parse("2013-06-28 10:31:14 +0200")) }
-  its(:imaginated_attribute) { should be_nil }
-
+  it {
+    expect(subject.id).to eq("pay_hViT20SOWaUL_w")
+    expect(subject.description).to eq("Zakupy z example.com")
+    expect(subject.amount).to eq("49.99")
+    expect(subject.currency).to eq("pln")
+    expect(subject.state).to eq("executed")
+    expect(subject.client).to eq("cli_wm7dGQltAqIfH8")
+    expect(subject.created_at).to eq(Time.parse("2013-06-28 10:31:14 +0200"))
+    expect(subject.imaginated_attribute).to be_nil
+  }
 end

data/spec/espago/router_spec.rb

@@ -6,12 +6,12 @@ class Espago::ApiConnection::StubbedRequestGet; end
 describe Espago::Router do
   subject { Espago::Router.new(:stubbed_request, :get) }
 
-  it { subject.should respond_to :path}
-  it { subject.should respond_to :method}
+  it { expect(subject).to respond_to :path}
+  it { expect(subject).to respond_to :method}
 
   context "#route" do
     it "should get a class name depending on path and method" do
-      subject.route.should eq( Espago::ApiConnection::StubbedRequestGet )
+      expect(subject.route).to eq( Espago::ApiConnection::StubbedRequestGet )
     end
 
     it "should raise error if class not found" do
@@ -22,14 +22,13 @@ describe Espago::Router do
 
   context "#path_exists?" do
     it "should return if path exists" do
-      subject.path_exists?.should be_true
+      expect(subject.path_exists?).to be_truthy
     end
 
     context "with invalid path name" do
       subject { Espago::Router.new(:not, :existing) }
-
       it "should return false" do
-        subject.path_exists?.should_not be_true
+        expect(subject.path_exists?).not_to be_truthy
       end
     end
   end

data/spec/features/apis_spec.rb

@@ -6,7 +6,7 @@ describe 'Two api headers test' do
     Espago.api_version = '2'
     VCR.use_cassette('api 2') do
       response = Espago.charges :get
-      response.count.should eq(596)
+      expect(response.count).to eq(596)
     end
   end
 
@@ -14,7 +14,7 @@ describe 'Two api headers test' do
     Espago.api_version = '3'
     VCR.use_cassette('api 3') do
       response = Espago.charges :get
-      response.count.should eq(596)
+      expect(response.count).to eq(596)
     end
   end
 

data/spec/features/charges_spec.rb

@@ -7,20 +7,20 @@ describe 'Espago.charges' do
   it "should get list of charges" do
     VCR.use_cassette('charges get') do
       response = Espago.charges :get
-      response.count.should eq(589)
+      expect(response.count).to eq(589)
     end
   end
 
   it "should get info abount charges" do
     VCR.use_cassette('charges get pay_mTOngouLTJWZ0w') do
       response = Espago.charges :get,{charge_id:'pay_mTOngouLTJWZ0w'}
-      response.status.should eq(200)
-      response.channel.should eq('elavon')
-      response.state.should eq('executed')
-      response.currency.should eq('PLN')
-      response.description.should eq('Test12345')
-      response.client.should eq('cli_YM5tKz6-IfhN7T')
-      response.created_at.should eq Time.at(1416917311)
+      expect(response.status).to eq(200)
+      expect(response.channel).to eq('elavon')
+      expect(response.state).to eq('executed')
+      expect(response.currency).to eq('PLN')
+      expect(response.description).to eq('Test12345')
+      expect(response.client).to eq('cli_YM5tKz6-IfhN7T')
+      expect(response.created_at).to eq Time.at(1416917311)
     end
   end
 
@@ -38,41 +38,41 @@ describe 'Espago.charges' do
                                            month:'2'
                                          },
                                          }
-      response.status.should eq(201)
-      response.channel.should eq('elavon')
-      response.state.should eq('executed')
-      response.currency.should eq('PLN')
-      response.description.should eq('Test12345')
-      response.client.should eq('cli_YM5tKz6-IfhN7T')
-      response.created_at.should eq Time.at(1416917311)
+      expect(response.status).to eq(201)
+      expect(response.channel).to eq('elavon')
+      expect(response.state).to eq('executed')
+      expect(response.currency).to eq('PLN')
+      expect(response.description).to eq('Test12345')
+      expect(response.client).to eq('cli_YM5tKz6-IfhN7T')
+      expect(response.created_at).to eq Time.at(1416917311)
     end
   end
 
   it "should get 204 status after destroy charge" do
     VCR.use_cassette('charges destroy') do
       response = Espago.charges :delete,{charge_id:'pay_kQmS_3RTfm4eix'}
-      response.state.should eq('reversed')
+      expect(response.state).to eq('reversed')
     end
   end
 
   it "should get refunded status after refund charge" do
     VCR.use_cassette('charges refund') do
       response = Espago.charges_refund :post,{charge_id:'pay_lQGyIon5qG59O5'}
-      response.state.should eq('refunded')
+      expect(response.state).to eq('refunded')
     end
   end
 
   it "should get params from complete charge" do
     VCR.use_cassette('charges complete') do
       response = Espago.charges_complete :post,{charge_id:'pay_kQmS_3RTfm4eix'}
-      response.state.should eq('executed')
+      expect(response.state).to eq('executed')
     end
   end
 
   it "should get params from complete charge (deprecated)" do
     VCR.use_cassette('charges complete deprecation') do
       response = Espago.complete :post,{charge_id:'pay_Wmu3hmXJIG4jsg'}
-      response.state.should eq('executed')
+      expect(response.state).to eq('executed')
     end
   end
 

data/spec/features/charges_spec_with_params_spec.rb

@@ -2,37 +2,37 @@
 require "spec_helper"
 
 describe 'Espago.charges_with_params' do
-  
+
   before :each do
       Espago.app_id = ''
       Espago.app_password = ''
       Espago.public_key = ''
       Espago.production = true
   end
-  
+
   it "should get list of charges" do
     VCR.use_cassette('charges get') do
       response = Espago.charges :get,{app_id: 'app_id_test', app_password: 'app_password_test', production: false}
-      response.count.should eq(589)
+      expect(response.count).to eq(589)
     end
   end
 
   it "should get info abount charges" do
     VCR.use_cassette('charges get pay_mTOngouLTJWZ0w') do
       response = Espago.charges :get,{charge_id:'pay_mTOngouLTJWZ0w', app_id: 'app_id_test', app_password: 'app_password_test', production: false}
-      response.status.should eq(200)
-      response.channel.should eq('elavon')
-      response.state.should eq('executed')
-      response.currency.should eq('PLN')
-      response.description.should eq('Test12345')
-      response.client.should eq('cli_YM5tKz6-IfhN7T')
-      response.created_at.should eq Time.at(1416917311)
+      expect(response.status).to eq(200)
+      expect(response.channel).to eq('elavon')
+      expect(response.state).to eq('executed')
+      expect(response.currency).to eq('PLN')
+      expect(response.description).to eq('Test12345')
+      expect(response.client).to eq('cli_YM5tKz6-IfhN7T')
+      expect(response.created_at).to eq Time.at(1416917311)
     end
   end
 
   it "should get params from new charge" do
     VCR.use_cassette('charges post') do
-      response = Espago.charges :post, { 
+      response = Espago.charges :post, {
                                          app_id: 'app_id_test',
                                          app_password: 'app_password_test',
                                          production: false,
@@ -48,41 +48,41 @@ describe 'Espago.charges_with_params' do
                                            month:'2'
                                          },
                                          }
-      response.status.should eq(201)
-      response.channel.should eq('elavon')
-      response.state.should eq('executed')
-      response.currency.should eq('PLN')
-      response.description.should eq('Test12345')
-      response.client.should eq('cli_YM5tKz6-IfhN7T')
-      response.created_at.should eq Time.at(1416917311)
+      expect(response.status).to eq(201)
+      expect(response.channel).to eq('elavon')
+      expect(response.state).to eq('executed')
+      expect(response.currency).to eq('PLN')
+      expect(response.description).to eq('Test12345')
+      expect(response.client).to eq('cli_YM5tKz6-IfhN7T')
+      expect(response.created_at).to eq Time.at(1416917311)
     end
   end
 
   it "should get 204 status after destroy charge" do
     VCR.use_cassette('charges destroy') do
       response = Espago.charges :delete,{charge_id:'pay_kQmS_3RTfm4eix', app_id: 'app_id_test', app_password: 'app_password_test', production: false}
-      response.state.should eq('reversed')
+      expect(response.state).to eq('reversed')
     end
   end
 
   it "should get refunded status after refund charge" do
     VCR.use_cassette('charges refund') do
       response = Espago.charges_refund :post,{charge_id:'pay_lQGyIon5qG59O5', app_id: 'app_id_test', app_password: 'app_password_test', production: false}
-      response.state.should eq('refunded')
+      expect(response.state).to eq('refunded')
     end
   end
 
   it "should get params from complete charge" do
     VCR.use_cassette('charges complete') do
       response = Espago.charges_complete :post,{charge_id:'pay_kQmS_3RTfm4eix', app_id: 'app_id_test', app_password: 'app_password_test', production: false}
-      response.state.should eq('executed')
+      expect(response.state).to eq('executed')
     end
   end
 
   it "should get params from complete charge (deprecated)" do
     VCR.use_cassette('charges complete deprecation') do
       response = Espago.complete :post,{charge_id:'pay_Wmu3hmXJIG4jsg', app_id: 'app_id_test', app_password: 'app_password_test', production: false}
-      response.state.should eq('executed')
+      expect(response.state).to eq('executed')
     end
   end
 

data/spec/features/clients_spec.rb

@@ -5,17 +5,17 @@ describe 'Espago.clients' do
   it "should get list of clients" do
     VCR.use_cassette('clients get') do
       response = Espago.clients :get
-      response.count.should eq(597)
+      expect(response.count).to eq(597)
     end
   end
 
   it "should get info abount clients" do
     VCR.use_cassette('clients get cli_w0Se2smYwyQ0Uw') do
       response = Espago.clients :get,{client_id:'cli_w0Se2smYwyQ0Uw'}
-      response.email.should eq(nil)
-      response.card['company'].should eq('VI')
-      response.description.should eq(nil)
-      response.created_at.should eq Time.at(1417004837)
+      expect(response.email).to eq(nil)
+      expect(response.card['company']).to eq('VI')
+      expect(response.description).to eq(nil)
+      expect(response.created_at).to eq Time.at(1417004837)
     end
   end
 
@@ -30,22 +30,22 @@ describe 'Espago.clients' do
                                            month:'2'
                                          },
                                          }
-      response.status.should eq(201)
-      response.card['company'].should eq('VI')
-      response.card['last4'].should eq('4242')
-      response.card['authorized'].should eq(nil)
-      response.deleted.should eq(false)
-      response.created_at.should eq Time.at(1417007099)
+      expect(response.status).to eq(201)
+      expect(response.card['company']).to eq('VI')
+      expect(response.card['last4']).to eq('4242')
+      expect(response.card['authorized']).to eq(nil)
+      expect(response.deleted).to eq(false)
+      expect(response.created_at).to eq Time.at(1417007099)
     end
   end
 
   it "should get status after authorize client card" do
     VCR.use_cassette('clients authorize') do
       response = Espago.clients_authorize :post,{client_id:'cli_w0Se2smYwyQ0Uw'}
-      response.status.should eq(201)
-      response.card['company'].should eq('VI')
-      response.card['last4'].should eq('1112')
-      response.card['authorized'].should eq(true)
+      expect(response.status).to eq(201)
+      expect(response.card['company']).to eq('VI')
+      expect(response.card['last4']).to eq('1112')
+      expect(response.card['authorized']).to eq(true)
     end
   end
 
@@ -62,21 +62,21 @@ describe 'Espago.clients' do
                                           month:'2'
                                         },
                                       }
-      response.status.should eq(200)
-      response.card['company'].should eq('VI')
-      response.card['last4'].should eq('4242')
-      response.card['authorized'].should eq(nil)
-      response.deleted.should eq(false)
-      response.created_at.should eq Time.at(1417004837)
+      expect(response.status).to eq(200)
+      expect(response.card['company']).to eq('VI')
+      expect(response.card['last4']).to eq('4242')
+      expect(response.card['authorized']).to eq(nil)
+      expect(response.deleted).to eq(false)
+      expect(response.created_at).to eq Time.at(1417004837)
     end
   end
 
   it "should get client invoices" do
     VCR.use_cassette('clients invoices') do
       response = Espago.clients_invoices :get, { client_id:'cli_w0Se2smYwyQ0Uw'}
-      response.status.should eq(200)
-      response.count.should eq(0)
-      response.invoices.should eq([])
+      expect(response.status).to eq(200)
+      expect(response.count).to eq(0)
+      expect(response.invoices).to eq([])
     end
   end
 
@@ -84,16 +84,16 @@ describe 'Espago.clients' do
   it "should get client subscriptions" do
     VCR.use_cassette('clients subscriptions') do
       response = Espago.clients_subscriptions :get, { client_id:'cli_w0Se2smYwyQ0Uw'}
-      response.status.should eq(200)
-      response.count.should eq(0)
-      response.subscriptions.should eq([])
+      expect(response.status).to eq(200)
+      expect(response.count).to eq(0)
+      expect(response.subscriptions).to eq([])
     end
   end
 
   it "should get status 204 after delete client" do
     VCR.use_cassette('clients delete') do
       response = Espago.clients :delete, { client_id:'cli_5rDoJyvKDM4RbM'}
-      response.status.should eq(204)
+      expect(response.status).to eq(204)
     end
   end
 

data/spec/features/dcc_decision_spec.rb

@@ -6,13 +6,13 @@ describe 'Espago.dcc_decision' do
   it "should get params from new charge" do
     VCR.use_cassette('dcc_decision post') do
       response = Espago.dcc_decision :post, {charge_id:'pay_mTOngouLTJWZ0w', decision:'Y'}
-      response.status.should eq(201)
-      response.channel.should eq('elavon')
-      response.state.should eq('executed')
-      response.currency.should eq('PLN')
-      response.description.should eq('Test12345')
-      response.client.should eq('cli_YM5tKz6-IfhN7T')
-      response.created_at.should eq Time.at(1416917311)
+      expect(response.status).to eq(201)
+      expect(response.channel).to eq('elavon')
+      expect(response.state).to eq('executed')
+      expect(response.currency).to eq('PLN')
+      expect(response.description).to eq('Test12345')
+      expect(response.client).to eq('cli_YM5tKz6-IfhN7T')
+      expect(response.created_at).to eq Time.at(1416917311)
     end
   end
 

data/spec/features/invoice_items_spec.rb

@@ -5,9 +5,9 @@ describe 'Espago.invoice_items' do
   it "should get info abount invoice_items" do
     VCR.use_cassette('invoice_items get ii_5LS-YR7S1QaJBl3') do
       response = Espago.invoice_items :get,{invoice_item_id:'ii_5LS-YR7S1QaJBl3'}
-      response.client.should eq('cli_90Pi6Jf0ndl_PP')
-      response.amount.should eq('123.45')
-      response.created_at.should eq Time.at(1417030496)
+      expect(response.client).to eq('cli_90Pi6Jf0ndl_PP')
+      expect(response.amount).to eq('123.45')
+      expect(response.created_at).to eq Time.at(1417030496)
     end
   end
 
@@ -19,18 +19,18 @@ describe 'Espago.invoice_items' do
                                               description: 'Test invoice items',
                                               client: 'cli_90Pi6Jf0ndl_PP'
                                             }
-      response.status.should eq(201)
-      response.client.should eq('cli_90Pi6Jf0ndl_PP')
-      response.amount.should eq('49.99')
-      response.currency.should eq('pln')
-      response.created_at.should eq Time.at(1417102491)
+      expect(response.status).to eq(201)
+      expect(response.client).to eq('cli_90Pi6Jf0ndl_PP')
+      expect(response.amount).to eq('49.99')
+      expect(response.currency).to eq('pln')
+      expect(response.created_at).to eq Time.at(1417102491)
     end
   end
 
     it "should get info abount deleted invoice_items" do
     VCR.use_cassette('invoice_items delete ii_WDzszvhTshe78Xd') do
       response = Espago.invoice_items :delete,{invoice_item_id:'ii_WDzszvhTshe78Xd'}
-      response.status.should eq(204)
+      expect(response.status).to eq(204)
     end
   end