vero 0.9.1 → 0.10.0

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

@@ -1,32 +1,34 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::Api::Workers::Users::UnsubscribeAPI do
-  subject { Vero::Api::Workers::Users::UnsubscribeAPI.new('https://api.getvero.com', {:auth_token => 'abcd', :email => 'test@test.com', :changes => { :email => 'test@test.com' }}) }
+  subject { Vero::Api::Workers::Users::UnsubscribeAPI.new('https://api.getvero.com', { auth_token: 'abcd', email: 'test@test.com', changes: { email: 'test@test.com' } }) }
 
-  it_behaves_like "a Vero wrapper" do
-    let(:end_point) { "/api/v2/users/unsubscribe.json" }
+  it_behaves_like 'a Vero wrapper' do
+    let(:end_point) { '/api/v2/users/unsubscribe.json' }
   end
 
   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
-      expect(RestClient).to receive(:post).with("https://api.getvero.com/api/v2/users/unsubscribe.json", {:auth_token => 'abcd', :email => 'test@test.com', :changes => { :email => 'test@test.com' }})
+    it 'should send a request to the Vero API' do
+      expect(RestClient).to receive(:post).with('https://api.getvero.com/api/v2/users/unsubscribe.json', { auth_token: 'abcd', email: 'test@test.com', changes: { email: 'test@test.com' } })
       allow(RestClient).to receive(:post).and_return(200)
       subject.send(:request)
     end
   end
 
-  describe "integration test" do
-    it "should not raise any errors" do
+  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

data/spec/lib/api_spec.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::Api::Events do
-  let (:subject) { Vero::Api::Events }
+  let(:subject) { Vero::Api::Events }
 
   describe :track! do
-    it "should call the TrackAPI object via the configured sender" do
-      input = {:event_name => "test_event", :identity => {:email => "james@getvero.com"}, :data => {:test => "test"}}
-      expected = input.merge(:auth_token => "abc123", :development_mode => true)
+    it 'should call the TrackAPI object via the configured sender' do
+      input = { event_name: 'test_event', identity: { email: 'james@getvero.com' }, data: { test: 'test' } }
+      expected = input.merge(auth_token: 'abc123', development_mode: true)
 
       mock_context = Vero::Context.new
       allow(mock_context.config).to receive(:configured?).and_return(true)
-      allow(mock_context.config).to receive(:auth_token).and_return("abc123")
+      allow(mock_context.config).to receive(:auth_token).and_return('abc123')
       allow(mock_context.config).to receive(:development_mode).and_return(true)
 
       allow(Vero::App).to receive(:default_context).and_return(mock_context)
 
-      expect(Vero::Sender).to receive(:send).with(Vero::Api::Workers::Events::TrackAPI, true, "https://api.getvero.com", expected)
+      expect(Vero::Sender).to receive(:send).with(Vero::Api::Workers::Events::TrackAPI, true, 'https://api.getvero.com', expected)
 
       subject.track!(input)
     end
@@ -25,67 +27,70 @@ end
 describe Vero::Api::Users do
   let(:subject) { Vero::Api::Users }
   let(:mock_context) { Vero::Context.new }
-  let(:expected) { input.merge(:auth_token => "abc123", :development_mode => true) }
+  let(:expected) { input.merge(auth_token: 'abc123', development_mode: true) }
 
   before :each do
     allow(mock_context.config).to receive(:configured?).and_return(true)
-    allow(mock_context.config).to receive(:auth_token).and_return("abc123")
+    allow(mock_context.config).to receive(:auth_token).and_return('abc123')
     allow(mock_context.config).to receive(:development_mode).and_return(true)
     allow(Vero::App).to receive(:default_context).and_return(mock_context)
   end
 
   describe :track! do
-    context "should call the TrackAPI object via the configured sender" do
-      let(:input) { {:email => "james@getvero.com", :data => {:age => 25}} }
+    context 'should call the TrackAPI object via the configured sender' do
+      let(:input) { { email: 'james@getvero.com', data: { age: 25 } } }
 
       specify do
-        expect(Vero::Sender).to receive(:send).with(Vero::Api::Workers::Users::TrackAPI, true, "https://api.getvero.com", expected)
+        expect(Vero::Sender).to receive(:send).with(Vero::Api::Workers::Users::TrackAPI, true, 'https://api.getvero.com', expected)
         subject.track!(input)
       end
     end
   end
 
   describe :edit_user! do
-    context "should call the TrackAPI object via the configured sender" do
-      let(:input) { {:email => "james@getvero.com", :changes => {:age => 25}} }
+    context 'should call the TrackAPI object via the configured sender' do
+      let(:input) { { email: 'james@getvero.com', changes: { age: 25 } } }
 
       specify do
-        expect(Vero::Sender).to receive(:send).with(Vero::Api::Workers::Users::EditAPI, true, "https://api.getvero.com", expected)
+        expect(Vero::Sender).to receive(:send).with(Vero::Api::Workers::Users::EditAPI, true, 'https://api.getvero.com', expected)
         subject.edit_user!(input)
       end
     end
   end
 
   describe :edit_user_tags! do
-    context "should call the TrackAPI object via the configured sender" do
-      let(:input) { {:add => ["boom"], :remove => ["tish"]} }
+    context 'should call the TrackAPI object via the configured sender' do
+      let(:input) { { add: ['boom'], remove: ['tish'] } }
 
       specify do
-        expect(Vero::Sender).to receive(:send).with(Vero::Api::Workers::Users::EditTagsAPI, true, "https://api.getvero.com", expected)
+        expect(Vero::Sender).to receive(:send).with(Vero::Api::Workers::Users::EditTagsAPI, true, 'https://api.getvero.com', expected)
         subject.edit_user_tags!(input)
       end
     end
   end
 
   describe :unsubscribe! do
-    context "should call the TrackAPI object via the configured sender" do
-      let(:input) { {:email => "james@getvero"} }
+    context 'should call the TrackAPI object via the configured sender' do
+      let(:input) { { email: 'james@getvero' } }
 
       specify do
-        expect(Vero::Sender).to receive(:send).with(Vero::Api::Workers::Users::UnsubscribeAPI, true, "https://api.getvero.com", expected)
+        expect(Vero::Sender).to receive(:send).with(Vero::Api::Workers::Users::UnsubscribeAPI, true, 'https://api.getvero.com', expected)
         subject.unsubscribe!(input)
       end
     end
   end
 
   describe :resubscribe! do
-    context "should call the TrackAPI object via the configured sender" do
-      let(:input) { {:email => "james@getvero"} }
+    context 'should call the TrackAPI object via the configured sender' do
+      let(:input) { { email: 'james@getvero' } }
 
       specify do
-        Vero::Sender.should_receive(:send).with(Vero::Api::Workers::Users::ResubscribeAPI, true, "https://api.getvero.com", expected)
+        expect(Vero::Sender).to(
+          receive(:send)
+          .with(Vero::Api::Workers::Users::ResubscribeAPI, true, 'https://api.getvero.com', expected)
+        )
         subject.resubscribe!(input)
       end
     end
   end
-end
+end

data/spec/lib/app_spec.rb

@@ -1,31 +1,33 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::App do
   describe 'self.default_context' do
-    it "inherits from Vero::Context" do
+    it 'inherits from Vero::Context' do
       actual = Vero::App.default_context
       expect(actual).to be_a(Vero::Context)
     end
   end
 
-  let (:context) { Vero::App.default_context }
+  let(:context) { Vero::App.default_context }
   describe :init do
-    it "should ignore configuring the config if no block is provided" do
+    it 'should ignore configuring the config if no block is provided' do
       Vero::App.init
       expect(context.configured?).to be(false)
     end
 
-    it "should pass configuration defined in the block to the config file" do
+    it 'should pass configuration defined in the block to the config file' do
       Vero::App.init
 
       expect(context.config.api_key).to be_nil
       Vero::App.init do |c|
-        c.api_key = "abcd1234"
+        c.api_key = 'abcd1234'
       end
-      expect(context.config.api_key).to eq("abcd1234")
+      expect(context.config.api_key).to eq('abcd1234')
     end
 
-    it "should init should be able to set async" do
+    it 'should init should be able to set async' do
       Vero::App.init do |c|
         c.async = false
       end
@@ -39,7 +41,7 @@ describe Vero::App do
   end
 
   describe :disable_requests! do
-    it "should change config.disabled" do
+    it 'should change config.disabled' do
       Vero::App.init {}
       expect(context.config.disabled).to be(false)
 
@@ -49,10 +51,10 @@ describe Vero::App do
   end
 
   describe :log do
-    it "should have a log method" do
+    it 'should have a log method' do
       Vero::App.init {}
       expect(Vero::App).to receive(:log)
-      Vero::App.log(Object, "test")
+      Vero::App.log(Object, 'test')
     end
   end
 end

data/spec/lib/config_spec.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::Config do
   let(:config) { Vero::Config.new }
 
-  it "should be async by default" do
+  it 'should be async by default' do
     expect(config.async).to be(true)
   end
 
   describe :reset! do
-    it "should reset all attributes" do
-      config.api_key = "abcd1234"
-      config.secret  = "abcd1234"
+    it 'should reset all attributes' do
+      config.api_key = 'abcd1234'
+      config.secret  = 'abcd1234'
       config.reset!
 
       expect(config.api_key).to be_nil
@@ -19,51 +21,51 @@ describe Vero::Config do
   end
 
   describe :auth_token do
-    it "should return nil if either api_key or secret are not set" do
+    it 'should return nil if either api_key or secret are not set' do
       config.api_key = nil
-      config.secret = "abcd"
+      config.secret = 'abcd'
       expect(config.auth_token).to be_nil
 
-      config.api_key = "abcd"
+      config.api_key = 'abcd'
       config.secret = nil
       expect(config.auth_token).to be_nil
 
-      config.api_key = "abcd"
-      config.secret = "abcd"
+      config.api_key = 'abcd'
+      config.secret = 'abcd'
       expect(config.auth_token).not_to be_nil
     end
 
-    it "should return an expected auth_token" do
-      config.api_key = "abcd1234"
-      config.secret = "efgh5678"
-      expect(config.auth_token).to eq("YWJjZDEyMzQ6ZWZnaDU2Nzg=")
+    it 'should return an expected auth_token' do
+      config.api_key = 'abcd1234'
+      config.secret = 'efgh5678'
+      expect(config.auth_token).to eq('YWJjZDEyMzQ6ZWZnaDU2Nzg=')
     end
   end
 
   describe :request_params do
-    it "should return a hash of auth_token and development_mode if they are set" do
+    it 'should return a hash of auth_token and development_mode if they are set' do
       config.api_key = nil
       config.secret = nil
       config.development_mode = nil
       expect(config.request_params).to eq({})
 
-      config.api_key = "abcd1234"
-      config.secret = "abcd1234"
-      expect(config.request_params).to eq({:auth_token => "YWJjZDEyMzQ6YWJjZDEyMzQ="})
+      config.api_key = 'abcd1234'
+      config.secret = 'abcd1234'
+      expect(config.request_params).to eq({ auth_token: 'YWJjZDEyMzQ6YWJjZDEyMzQ=' })
 
       config.development_mode = true
-      expect(config.request_params).to eq({:auth_token => "YWJjZDEyMzQ6YWJjZDEyMzQ=", :development_mode => true})
+      expect(config.request_params).to eq({ auth_token: 'YWJjZDEyMzQ6YWJjZDEyMzQ=', development_mode: true })
     end
   end
 
   describe :domain do
-    it "should return https://api.getvero.com when not set" do
+    it 'should return https://api.getvero.com when not set' do
       expect(config.domain).to eq('https://api.getvero.com')
       config.domain = 'blah.com'
       expect(config.domain).not_to eq('https://api.getvero.com')
     end
 
-    it "should return the domain value" do
+    it 'should return the domain value' do
       config.domain = 'test.unbelieveable.com.au'
       expect(config.domain).to eq('http://test.unbelieveable.com.au')
 
@@ -73,24 +75,24 @@ describe Vero::Config do
   end
 
   describe :development_mode do
-    it "by default it should return false regardless of Rails environment" do
-      stub_env('development') {
+    it 'by default it should return false regardless of Rails environment' do
+      stub_env('development') do
         config = Vero::Config.new
         expect(config.development_mode).to be(false)
-      }
+      end
 
-      stub_env('test') {
+      stub_env('test') do
         config = Vero::Config.new
         expect(config.development_mode).to be(false)
-      }
+      end
 
-      stub_env('production') {
+      stub_env('production') do
         config = Vero::Config.new
         expect(config.development_mode).to be(false)
-      }
+      end
     end
 
-    it "can be overritten with the config block" do
+    it 'can be overritten with the config block' do
       config.development_mode = true
       expect(config.request_params[:development_mode]).to be(true)
 
@@ -101,7 +103,7 @@ describe Vero::Config do
 
   describe :test_mode do
     it 'should not raise error even though not configured properly' do
-      input = {:event_name => "test_event"}
+      input = { event_name: 'test_event' }
       mock_context = Vero::Context.new
       allow(mock_context.config).to receive(:configured?).and_return(false)
 

data/spec/lib/context_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe Vero::Context do 
+describe Vero::Context do
   let(:context) { Vero::Context.new }
 
-  it "accepts multiple parameter types in contructor" do
-    context1 = Vero::Context.new({ :api_key => 'blah', :secret => 'didah' })
+  it 'accepts multiple parameter types in contructor' do
+    context1 = Vero::Context.new({ api_key: 'blah', secret: 'didah' })
     expect(context1).to be_a(Vero::Context)
     expect(context1.config.api_key).to eq('blah')
     expect(context1.config.secret).to eq('didah')
@@ -22,19 +24,19 @@ describe Vero::Context do
   end
 
   describe :configure do
-    it "should ignore configuring the config if no block is provided" do
+    it 'should ignore configuring the config if no block is provided' do
       context.configure
       expect(context.configured?).to be(false)
     end
 
-    it "should pass configuration defined in the block to the config file" do
+    it 'should pass configuration defined in the block to the config file' do
       context.configure do |c|
-        c.api_key = "abcd1234"
+        c.api_key = 'abcd1234'
       end
-      expect(context.config.api_key).to eq("abcd1234")
+      expect(context.config.api_key).to eq('abcd1234')
     end
 
-    it "should init should be able to set async" do
+    it 'should init should be able to set async' do
       context.configure do |c|
         c.async = false
       end
@@ -48,10 +50,10 @@ describe Vero::Context do
   end
 
   describe :disable_requests! do
-    it "should change config.disabled" do
+    it 'should change config.disabled' do
       expect(context.config.disabled).to be(false)
       context.disable_requests!
-      expect(context.config.disabled).to be(true)            
+      expect(context.config.disabled).to be(true)
     end
   end
-end
+end

data/spec/lib/dsl_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::DSL do
@@ -18,7 +20,7 @@ describe Vero::DSL::Proxy do
       expect(proxy.users).to eql(Vero::Api::Users)
     end
 
-    it "should respond to reidentify!" do
+    it 'should respond to reidentify!' do
       expect(proxy.users.respond_to?(:reidentify!)).to be(true)
     end
   end

data/spec/lib/sender_spec.rb

@@ -1,34 +1,22 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::Sender do
   subject { Vero::Sender }
 
-  describe ".senders" do
-    it "should be a Hash" do
-      expect(subject.senders).to be_a(Hash)
-    end
-
-    context 'when using Ruby with verion greater than 1.8.7' do
-      before do
-        stub_const('RUBY_VERSION', '1.9.3')
-      end
-
-      it "should have a default set of senders (true, false, none, thread)" do
-        expect(subject.senders).to eq({
-          true          => Vero::Senders::Thread,
-          false         => Vero::Senders::Base,
-          :none         => Vero::Senders::Base,
-          :thread       => Vero::Senders::Thread,
-        })
-      end
+  describe '.senders' do
+    it 'should automatically find senders that are not defined' do
+      expect(subject.senders[:delayed_job]).to eq(Vero::Senders::DelayedJob)
+      expect(subject.senders[:sucker_punch]).to eq(Vero::Senders::SuckerPunch)
+      expect(subject.senders[:resque]).to eq(Vero::Senders::Resque)
+      expect(subject.senders[:sidekiq]).to eq(Vero::Senders::Sidekiq)
+      expect(subject.senders[:invalid]).to eq(Vero::Senders::Invalid)
+      expect(subject.senders[:none]).to eq(Vero::Senders::Base)
     end
 
-    it "should automatically find senders that are not defined" do
-      expect(subject.senders[:delayed_job]).to  eq(Vero::Senders::DelayedJob)
-      expect(subject.senders[:resque]).to       eq(Vero::Senders::Resque)
-      expect(subject.senders[:sidekiq]).to      eq(Vero::Senders::Sidekiq)
-      expect(subject.senders[:invalid]).to      eq(Vero::Senders::Invalid)
-      expect(subject.senders[:none]).to         eq(Vero::Senders::Base)
+    it 'should fallback to Vero::Senders::Base' do
+      expect(subject.senders[:unsupported_sender]).to eq(Vero::Senders::Base)
     end
   end
 end