vero 0.7.0 → 0.10.0

data/spec/lib/api/base_api_spec.rb

@@ -1,17 +1,19 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 describe Vero::Api::Workers::BaseAPI do
-  let (:subject) { Vero::Api::Workers::BaseAPI.new("http://www.getvero.com", {}) }
+  let(:subject) { Vero::Api::Workers::BaseAPI.new('http://www.getvero.com', {}) }
 
   describe :options_with_symbolized_keys do
-    it "should create a new options Hash with symbol keys (much like Hash#symbolize_keys in rails)" do
-      subject.options.should == {}
+    it 'should create a new options Hash with symbol keys (much like Hash#symbolize_keys in rails)' do
+      expect(subject.options).to eq({})
 
-      subject.options = {:abc => 123}
-      subject.options.should == {:abc => 123}
+      subject.options = { abc: 123 }
+      expect(subject.options).to eq({ abc: 123 })
 
-      subject.options = {"abc" => 123}
-      subject.options.should == {:abc => 123}
+      subject.options = { 'abc' => 123 }
+      expect(subject.options).to eq({ abc: 123 })
     end
   end
-end
+end

data/spec/lib/api/events/track_api_spec.rb

@@ -1,67 +1,67 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::Api::Workers::Events::TrackAPI do
+  subject { Vero::Api::Workers::Events::TrackAPI.new('https://api.getvero.com', { auth_token: 'abcd', identity: { email: 'test@test.com' }, event_name: 'test_event' }) }
 
-  context "request without properties" do
-    subject { Vero::Api::Workers::Events::TrackAPI.new('https://api.getvero.com', {}) }
-    it "should inherit from Vero::Api::Workers::BaseCaller" do
-      subject.should be_a(Vero::Api::Workers::BaseAPI)
-    end
-
-    it "should map to current version of Vero API" do
-      subject.send(:url).should == "https://api.getvero.com/api/v2/events/track.json"
-    end
+  it_behaves_like 'a Vero wrapper' do
+    let(:end_point) { '/api/v2/events/track.json' }
   end
 
-  context "request with properties" do
-    subject { Vero::Api::Workers::Events::TrackAPI.new('https://api.getvero.com', {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event'}) }
+  context 'request with properties' do
     describe :validate! do
-      it "should raise an error if event_name is a blank String" do
-        options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => nil}
+      it 'should raise an error if event_name is a blank String' do
+        options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, event_name: nil }
         subject.options = options
-        expect { subject.send(:validate!) }.to raise_error
+        expect { subject.send(:validate!) }.to raise_error(ArgumentError)
 
-        options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event'}
+        options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, event_name: 'test_event' }
         subject.options = options
         expect { subject.send(:validate!) }.to_not raise_error
       end
 
-      it "should raise an error if data is not either nil or a Hash" do
-        options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event', :data => []}
+      it 'should raise an error if data is not either nil or a Hash' do
+        options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, event_name: 'test_event', data: [] }
         subject.options = options
-        expect { subject.send(:validate!) }.to raise_error
+        expect { subject.send(:validate!) }.to raise_error(ArgumentError)
 
-        options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event', :data => nil}
+        options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, event_name: 'test_event', data: nil }
         subject.options = options
         expect { subject.send(:validate!) }.to_not raise_error
 
-        options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event', :data => {}}
+        options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, event_name: 'test_event', data: {} }
         subject.options = options
         expect { subject.send(:validate!) }.to_not raise_error
       end
 
-      it "should not raise an error when the keys are Strings" do
-        options = {"auth_token" => 'abcd', "identity" => {"email" => 'test@test.com'}, "event_name" => 'test_event', "data" => {}}
+      it 'should not raise an error when the keys are Strings' do
+        options = { 'auth_token' => 'abcd', 'identity' => { 'email' => 'test@test.com' }, 'event_name' => 'test_event', 'data' => {} }
         subject.options = options
         expect { subject.send(:validate!) }.to_not raise_error
       end
+
+      it 'should not raise an error when keys are Strings for initialization' do
+        options = { 'auth_token' => 'abcd', 'identity' => { 'email' => 'test@test.com' }, 'event_name' => 'test_event', 'data' => {} }
+        expect { Vero::Api::Workers::Events::TrackAPI.new('https://api.getvero.com', options).send(:validate!) }.to_not raise_error
+      end
     end
 
     describe :request do
-      it "should send a JSON request to the Vero API" do
-        RestClient.should_receive(:post).with("https://api.getvero.com/api/v2/events/track.json", {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event'}.to_json, {:content_type => :json, :accept => :json})
-        RestClient.stub(:post).and_return(200)
+      it 'should send a JSON request to the Vero API' do
+        expect(RestClient).to receive(:post).with('https://api.getvero.com/api/v2/events/track.json', { auth_token: 'abcd', identity: { email: 'test@test.com' }, event_name: 'test_event' }.to_json, { content_type: :json, accept: :json })
+        allow(RestClient).to receive(:post).and_return(200)
         subject.send(:request)
       end
     end
   end
 
-  describe "integration test" do
-    it "should not raise any errors" do
-      obj = Vero::Api::Workers::Events::TrackAPI.new('https://api.getvero.com', {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event'})
+  describe 'integration test' do
+    it 'should not raise any errors' do
+      obj = Vero::Api::Workers::Events::TrackAPI.new('https://api.getvero.com', { auth_token: 'abcd', identity: { email: 'test@test.com' }, event_name: 'test_event' })
 
-      RestClient.stub(:post).and_return(200)
+      allow(RestClient).to receive(:post).and_return(200)
       expect { obj.perform }.to_not raise_error
     end
   end
-end
+end

data/spec/lib/api/users/delete_api_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Vero::Api::Workers::Users::DeleteAPI do
+  subject { Vero::Api::Workers::Users::DeleteAPI.new('https://api.getvero.com', {:auth_token => 'abcd', :id => '1234'}) }
+
+  it_behaves_like "a Vero wrapper" do
+    let(:end_point) { "/api/v2/users/delete.json" }
+  end
+
+  it_behaves_like "a Vero wrapper" do
+    let(:end_point) { "/api/v2/users/delete.json" }
+  end
+
+  describe :validate! do
+    it "should not raise an error when the keys are Strings" do
+      subject.options = {"auth_token" => 'abcd', "id" => '1234'}
+      expect { subject.send(:validate!) }.to_not raise_error
+    end
+
+    it "should raise an error for missing keys" do
+      subject.options = {"auth_token" => 'abcd'}
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe :request do
+    it "should send a request to the Vero API" do
+      RestClient.should_receive(:post).with("https://api.getvero.com/api/v2/users/delete.json", {:auth_token => 'abcd', :id => '1234'})
+      RestClient.stub(:post).and_return(200)
+      subject.send(:request)
+    end
+  end
+end

data/spec/lib/api/users/edit_api_spec.rb

@@ -1,36 +1,34 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::Api::Workers::Users::EditAPI do
-  subject { Vero::Api::Workers::Users::EditAPI.new('https://api.getvero.com', {}) }
-  it "should inherit from Vero::Api::Workers::BaseCaller" do
-    subject.should be_a(Vero::Api::Workers::BaseAPI)
-  end
+  subject { Vero::Api::Workers::Users::EditAPI.new('https://api.getvero.com', { auth_token: 'abcd', email: 'test@test.com', changes: { email: 'test@test.com' } }) }
 
-  it "should map to current version of Vero API" do
-    subject.send(:url).should == "https://api.getvero.com/api/v2/users/edit.json"
+  it_behaves_like 'a Vero wrapper' do
+    let(:end_point) { '/api/v2/users/edit.json' }
   end
 
-  subject { Vero::Api::Workers::Users::EditAPI.new('https://api.getvero.com', {:auth_token => 'abcd', :email => 'test@test.com', :changes => { :email => 'test@test.com' }}) }
   describe :validate! do
-    it "should not raise an error when the keys are Strings" do
-      options = {"auth_token" => 'abcd', "email" => 'test@test.com', "changes" => { "email" => 'test@test.com' }}
+    it 'should not raise an error when the keys are Strings' do
+      options = { 'auth_token' => 'abcd', 'email' => 'test@test.com', 'changes' => { 'email' => 'test@test.com' } }
       subject.options = options
       expect { subject.send(:validate!) }.to_not raise_error
     end
   end
 
   describe :request do
-    it "should send a request to the Vero API" do
-      RestClient.should_receive(:put).with("https://api.getvero.com/api/v2/users/edit.json", {:auth_token => 'abcd', :email => 'test@test.com', :changes => { :email => 'test@test.com' }}.to_json, {:content_type => :json, :accept => :json})
-      RestClient.stub(:put).and_return(200)
+    it 'should send a request to the Vero API' do
+      expect(RestClient).to receive(:put).with('https://api.getvero.com/api/v2/users/edit.json', { auth_token: 'abcd', email: 'test@test.com', changes: { email: 'test@test.com' } }.to_json, { content_type: :json, accept: :json })
+      allow(RestClient).to receive(:put).and_return(200)
       subject.send(:request)
     end
   end
 
-  describe "integration test" do
-    it "should not raise any errors" do
-      RestClient.stub(:put).and_return(200)
+  describe 'integration test' do
+    it 'should not raise any errors' do
+      allow(RestClient).to receive(:put).and_return(200)
       expect { subject.perform }.to_not raise_error
     end
   end
-end
+end

data/spec/lib/api/users/edit_tags_api_spec.rb

@@ -1,74 +1,71 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::Api::Workers::Users::EditTagsAPI do
-  subject { Vero::Api::Workers::Users::EditTagsAPI.new('https://api.getvero.com', {}) }
-  it "should inherit from Vero::Api::Workers::BaseCaller" do
-    subject.should be_a(Vero::Api::Workers::BaseAPI)
-  end
+  subject { Vero::Api::Workers::Users::EditTagsAPI.new('https://api.getvero.com', { auth_token: 'abcd', email: 'test@test.com', add: ['test'] }) }
 
-  it "should map to current version of Vero API" do
-    subject.send(:url).should == "https://api.getvero.com/api/v2/users/tags/edit.json"
+  it_behaves_like 'a Vero wrapper' do
+    let(:end_point) { '/api/v2/users/tags/edit.json' }
   end
 
-  subject { Vero::Api::Workers::Users::EditTagsAPI.new('https://api.getvero.com', {:auth_token => 'abcd', :email => 'test@test.com', :add => ["test"]}) }
-
   describe :validate! do
-    it "should raise an error if email is a blank String" do
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => nil, :add => []}
+    it 'should raise an error if email is a blank String' do
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, email: nil, add: [] }
       subject.options = options
-      expect { subject.send(:validate!) }.to raise_error
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
 
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com', :add => []}
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, email: 'test@test.com', add: [] }
       subject.options = options
       expect { subject.send(:validate!) }.to_not raise_error
     end
 
-    it "should raise an error if add is not an Array or missing" do
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com', :add => "foo" }
+    it 'should raise an error if add is not an Array or missing' do
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, email: 'test@test.com', add: 'foo' }
 
       subject.options = options
-      expect { subject.send(:validate!) }.to raise_error
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
     end
 
-    it "should raise an error if remove is not an Array or missing" do
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com', :remove => "foo" }
+    it 'should raise an error if remove is not an Array or missing' do
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, email: 'test@test.com', remove: 'foo' }
 
       subject.options = options
-      expect { subject.send(:validate!) }.to raise_error
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
     end
 
-    it "should raise an error if botha add and remove are missing" do
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com'}
+    it 'should raise an error if botha add and remove are missing' do
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, email: 'test@test.com' }
 
       subject.options = options
-      expect { subject.send(:validate!) }.to raise_error
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
     end
 
-    it "should not raise an error if the correct arguments are passed" do
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com', :remove => [ "Hi" ] }
+    it 'should not raise an error if the correct arguments are passed' do
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, email: 'test@test.com', remove: ['Hi'] }
 
       subject.options = options
       expect { subject.send(:validate!) }.to_not raise_error
     end
 
-    it "should not raise an error when the keys are Strings" do
-      options = {"auth_token" => 'abcd', "identity" => {"email" => 'test@test.com'}, "email" => 'test@test.com', "remove" => [ "Hi" ] }
+    it 'should not raise an error when the keys are Strings' do
+      options = { 'auth_token' => 'abcd', 'identity' => { 'email' => 'test@test.com' }, 'email' => 'test@test.com', 'remove' => ['Hi'] }
       subject.options = options
       expect { subject.send(:validate!) }.to_not raise_error
     end
   end
 
   describe :request do
-    it "should send a request to the Vero API" do
-      RestClient.should_receive(:put).with("https://api.getvero.com/api/v2/users/tags/edit.json", {:auth_token => 'abcd', :email => 'test@test.com', :add => ["test"]}.to_json, {:content_type => :json, :accept => :json})
-      RestClient.stub(:put).and_return(200)
+    it 'should send a request to the Vero API' do
+      expect(RestClient).to receive(:put).with('https://api.getvero.com/api/v2/users/tags/edit.json', { auth_token: 'abcd', email: 'test@test.com', add: ['test'] }.to_json, { content_type: :json, accept: :json })
+      allow(RestClient).to receive(:put).and_return(200)
       subject.send(:request)
     end
   end
 
-  describe "integration test" do
-    it "should not raise any errors" do
-      RestClient.stub(:put).and_return(200)
+  describe 'integration test' do
+    it 'should not raise any errors' do
+      allow(RestClient).to receive(:put).and_return(200)
       expect { subject.perform }.to_not raise_error
     end
   end

data/spec/lib/api/users/reidentify_spec.rb

@@ -1,46 +1,44 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::Api::Workers::Users::ReidentifyAPI do
-  subject { Vero::Api::Workers::Users::ReidentifyAPI.new('https://api.getvero.com', {}) }
-  it "should inherit from Vero::Api::Workers::BaseCaller" do
-    subject.should be_a(Vero::Api::Workers::BaseAPI)
-  end
+  subject { Vero::Api::Workers::Users::ReidentifyAPI.new('https://api.getvero.com', { auth_token: 'abcd', id: 'test@test.com', new_id: 'test2@test.com' }) }
 
-  it "should map to current version of Vero API" do
-    subject.send(:url).should == "https://api.getvero.com/api/v2/users/reidentify.json"
+  it_behaves_like 'a Vero wrapper' do
+    let(:end_point) { '/api/v2/users/reidentify.json' }
   end
 
-  subject { Vero::Api::Workers::Users::ReidentifyAPI.new('https://api.getvero.com', {:auth_token => 'abcd', :id => 'test@test.com', :new_id => 'test2@test.com'}) }
   describe :validate! do
-    it "should not raise an error when the keys are Strings" do
-      options = {"auth_token" => 'abcd', "id" => 'test@test.com', "new_id" => 'test2@test.com'}
+    it 'should not raise an error when the keys are Strings' do
+      options = { 'auth_token' => 'abcd', 'id' => 'test@test.com', 'new_id' => 'test2@test.com' }
       subject.options = options
       expect { subject.send(:validate!) }.to_not raise_error
     end
 
-    it "should raise an error if id is missing" do
-      subject.options = {:auth_token => 'abcd', :new_id => 'test2@test.com'}
-      expect { subject.send(:validate!) }.to raise_error
+    it 'should raise an error if id is missing' do
+      subject.options = { auth_token: 'abcd', new_id: 'test2@test.com' }
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
     end
 
-    it "should raise an error if new_id is missing" do
-      subject.options = {:auth_token => 'abcd', :id => 'test@test.com'}
-      expect { subject.send(:validate!) }.to raise_error
+    it 'should raise an error if new_id is missing' do
+      subject.options = { auth_token: 'abcd', id: 'test@test.com' }
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
     end
   end
 
   describe :request do
-    it "should send a request to the Vero API" do
-      RestClient.should_receive(:put).with("https://api.getvero.com/api/v2/users/reidentify.json", {:auth_token => 'abcd', :id => 'test@test.com', :new_id => 'test2@test.com'}.to_json, {:content_type => :json, :accept => :json})
-      RestClient.stub(:put).and_return(200)
+    it 'should send a request to the Vero API' do
+      expect(RestClient).to receive(:put).with('https://api.getvero.com/api/v2/users/reidentify.json', { auth_token: 'abcd', id: 'test@test.com', new_id: 'test2@test.com' }.to_json, { content_type: :json, accept: :json })
+      allow(RestClient).to receive(:put).and_return(200)
       subject.send(:request)
     end
   end
 
-  describe "integration test" do
-    it "should not raise any errors" do
-      RestClient.stub(:put).and_return(200)
+  describe 'integration test' do
+    it 'should not raise any errors' do
+      allow(RestClient).to receive(:put).and_return(200)
       expect { subject.perform }.to_not raise_error
     end
   end
-end
+end

data/spec/lib/api/users/resubscribe_api_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Vero::Api::Workers::Users::ResubscribeAPI do
+  subject { Vero::Api::Workers::Users::ResubscribeAPI.new('https://api.getvero.com', { auth_token: 'abcd', id: '1234' }) }
+
+  it_behaves_like 'a Vero wrapper' do
+    let(:end_point) { '/api/v2/users/resubscribe.json' }
+  end
+
+  describe :validate! do
+    it 'should not raise an error when the keys are Strings' do
+      subject.options = { 'auth_token' => 'abcd', 'id' => '1234' }
+      expect { subject.send(:validate!) }.to_not raise_error
+    end
+
+    it 'should raise an error for missing keys' do
+      subject.options = { 'auth_token' => 'abcd' }
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe :request do
+    it 'should send a request to the Vero API' do
+      expect(RestClient).to(
+        receive(:post)
+        .with('https://api.getvero.com/api/v2/users/resubscribe.json', { auth_token: 'abcd', id: '1234' })
+      )
+      allow(RestClient).to receive(:post).and_return(200)
+
+      subject.send(:request)
+    end
+  end
+end

data/spec/lib/api/users/track_api_spec.rb

@@ -1,68 +1,66 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::Api::Workers::Users::TrackAPI do
-  subject { Vero::Api::Workers::Users::TrackAPI.new('https://api.getvero.com', {}) }
-  it "should inherit from Vero::Api::Workers::BaseCaller" do
-    subject.should be_a(Vero::Api::Workers::BaseAPI)
-  end
+  subject { Vero::Api::Workers::Users::TrackAPI.new('https://api.getvero.com', { auth_token: 'abcd', identity: { email: 'test@test.com' }, email: 'test@test.com' }) }
 
-  it "should map to current version of Vero API" do
-    subject.send(:url).should == "https://api.getvero.com/api/v2/users/track.json"
+  it_behaves_like 'a Vero wrapper' do
+    let(:end_point) { '/api/v2/users/track.json' }
   end
 
-  subject { Vero::Api::Workers::Users::TrackAPI.new('https://api.getvero.com', {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com'}) }
   describe :validate! do
-    it "should raise an error if email and id are are blank String" do
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :id => nil, :email => nil}
+    it 'should raise an error if email and id are are blank String' do
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, id: nil, email: nil }
       subject.options = options
-      expect { subject.send(:validate!) }.to raise_error
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
 
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :id => nil, :email => 'test@test.com'}
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, id: nil, email: 'test@test.com' }
       subject.options = options
       expect { subject.send(:validate!) }.to_not raise_error
 
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :id => "", :email => nil}
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, id: '', email: nil }
       subject.options = options
-      expect { subject.send(:validate!) }.to raise_error
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
 
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :id => "user123", :email => nil}
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, id: 'user123', email: nil }
       subject.options = options
       expect { subject.send(:validate!) }.to_not raise_error
     end
 
-    it "should raise an error if data is not either nil or a Hash" do
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com', :data => []}
+    it 'should raise an error if data is not either nil or a Hash' do
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, email: 'test@test.com', data: [] }
       subject.options = options
-      expect { subject.send(:validate!) }.to raise_error
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
 
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com', :data => nil}
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, email: 'test@test.com', data: nil }
       subject.options = options
       expect { subject.send(:validate!) }.to_not raise_error
 
-      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com', :data => {}}
+      options = { auth_token: 'abcd', identity: { email: 'test@test.com' }, email: 'test@test.com', data: {} }
       subject.options = options
       expect { subject.send(:validate!) }.to_not raise_error
     end
 
-    it "should not raise an error when the keys are Strings" do
-      options = {"auth_token" => 'abcd', "identity" => {"email" => 'test@test.com'}, "email" => 'test@test.com', "data" => {}}
+    it 'should not raise an error when the keys are Strings' do
+      options = { 'auth_token' => 'abcd', 'identity' => { 'email' => 'test@test.com' }, 'email' => 'test@test.com', 'data' => {} }
       subject.options = options
       expect { subject.send(:validate!) }.to_not raise_error
     end
   end
 
   describe :request do
-    it "should send a request to the Vero API" do
-      RestClient.should_receive(:post).with("https://api.getvero.com/api/v2/users/track.json", {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com'}.to_json, {:content_type => :json, :accept => :json})
-      RestClient.stub(:post).and_return(200)
+    it 'should send a request to the Vero API' do
+      expect(RestClient).to receive(:post).with('https://api.getvero.com/api/v2/users/track.json', { auth_token: 'abcd', identity: { email: 'test@test.com' }, email: 'test@test.com' }.to_json, { content_type: :json, accept: :json })
+      allow(RestClient).to receive(:post).and_return(200)
       subject.send(:request)
     end
   end
 
-  describe "integration test" do
-    it "should not raise any errors" do
-      RestClient.stub(:post).and_return(200)
+  describe 'integration test' do
+    it 'should not raise any errors' do
+      allow(RestClient).to receive(:post).and_return(200)
       expect { subject.perform }.to_not raise_error
     end
   end
-end
+end