vero 0.7.0 → 0.10.0

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

@@ -1,36 +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', {}) }
-  it "should inherit from Vero::Api::Workers::BaseCaller" do
-    subject.should be_a(Vero::Api::Workers::BaseAPI)
-  end
+  subject { Vero::Api::Workers::Users::UnsubscribeAPI.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/unsubscribe.json"
+  it_behaves_like 'a Vero wrapper' do
+    let(:end_point) { '/api/v2/users/unsubscribe.json' }
   end
 
-  subject { Vero::Api::Workers::Users::UnsubscribeAPI.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(:post).with("https://api.getvero.com/api/v2/users/unsubscribe.json", {:auth_token => 'abcd', :email => 'test@test.com', :changes => { :email => 'test@test.com' }})
-      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/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
-      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

data/spec/lib/api_spec.rb

@@ -1,20 +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
-      mock_context.config.stub(:configured?).and_return(true)
-      mock_context.config.stub(:auth_token).and_return("abc123")
+      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(:development_mode).and_return(true)
 
-      Vero::App.stub(:default_context).and_return(mock_context)
+      allow(Vero::App).to receive(:default_context).and_return(mock_context)
 
-      Vero::Sender.should_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
@@ -22,73 +25,72 @@ describe Vero::Api::Events do
 end
 
 describe Vero::Api::Users do
-  let (:subject) { Vero::Api::Users }
+  let(:subject) { Vero::Api::Users }
+  let(:mock_context) { Vero::Context.new }
+  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(:development_mode).and_return(true)
+    allow(Vero::App).to receive(:default_context).and_return(mock_context)
+  end
 
   describe :track! do
-    it "should call the TrackAPI object via the configured sender" do
-      input = {:email => "james@getvero.com", :data => {:age => 25}}
-      expected = input.merge(:auth_token => "abc123", :development_mode => true)
-
-      mock_context = Vero::Context.new
-      mock_context.config.stub(:configured?).and_return(true)
-      mock_context.config.stub(:auth_token).and_return("abc123")
-
-      Vero::App.stub(:default_context).and_return(mock_context)
-
-      Vero::Sender.should_receive(:send).with(Vero::Api::Workers::Users::TrackAPI, true, "https://api.getvero.com", expected)
+    context 'should call the TrackAPI object via the configured sender' do
+      let(:input) { { email: 'james@getvero.com', data: { age: 25 } } }
 
-      subject.track!(input)
+      specify do
+        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
-    it "should call the TrackAPI object via the configured sender" do
-      input = {:email => "james@getvero.com", :changes => {:age => 25}}
-      expected = input.merge(:auth_token => "abc123", :development_mode => true)
-
-      mock_context = Vero::Context.new
-      mock_context.config.stub(:configured?).and_return(true)
-      mock_context.config.stub(:auth_token).and_return("abc123")
-
-      Vero::App.stub(:default_context).and_return(mock_context)
-
-      Vero::Sender.should_receive(:send).with(Vero::Api::Workers::Users::EditAPI, true, "https://api.getvero.com", expected)
+    context 'should call the TrackAPI object via the configured sender' do
+      let(:input) { { email: 'james@getvero.com', changes: { age: 25 } } }
 
-      subject.edit_user!(input)
+      specify do
+        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
-    it "should call the TrackAPI object via the configured sender" do
-      input = {:add => ["boom"], :remove => ["tish"]}
-      expected = input.merge(:auth_token => "abc123", :development_mode => true)
+    context 'should call the TrackAPI object via the configured sender' do
+      let(:input) { { add: ['boom'], remove: ['tish'] } }
 
-      mock_context = Vero::Context.new
-      mock_context.config.stub(:configured?).and_return(true)
-      mock_context.config.stub(:auth_token).and_return("abc123")
-
-      Vero::App.stub(:default_context).and_return(mock_context)
-
-      Vero::Sender.should_receive(:send).with(Vero::Api::Workers::Users::EditTagsAPI, true, "https://api.getvero.com", expected)
-
-      subject.edit_user_tags!(input)
+      specify do
+        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
-    it "should call the TrackAPI object via the configured sender" do
-      input = {:email => "james@getvero"}
-      expected = input.merge(:auth_token => "abc123", :development_mode => true)
-
-      mock_context = Vero::Context.new
-      mock_context.config.stub(:configured?).and_return(true)
-      mock_context.config.stub(:auth_token).and_return("abc123")
-
-      Vero::App.stub(:default_context).and_return(mock_context)
+    context 'should call the TrackAPI object via the configured sender' do
+      let(:input) { { email: 'james@getvero' } }
 
-      Vero::Sender.should_receive(:send).with(Vero::Api::Workers::Users::UnsubscribeAPI, true, "https://api.getvero.com", expected)
+      specify do
+        expect(Vero::Sender).to receive(:send).with(Vero::Api::Workers::Users::UnsubscribeAPI, true, 'https://api.getvero.com', expected)
+        subject.unsubscribe!(input)
+      end
+    end
+  end
 
-      subject.unsubscribe!(input)
+  describe :resubscribe! do
+    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::ResubscribeAPI, true, 'https://api.getvero.com', expected)
+        )
+        subject.resubscribe!(input)
+      end
     end
   end
-end
+end

data/spec/lib/app_spec.rb

@@ -1,58 +1,60 @@
+# 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
-      actual.should be_a(Vero::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
-      context.configured?.should be_false
+      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
 
-      context.config.api_key.should be_nil
+      expect(context.config.api_key).to be_nil
       Vero::App.init do |c|
-        c.api_key = "abcd1234"
+        c.api_key = 'abcd1234'
       end
-      context.config.api_key.should == "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
-      context.config.async.should be_false
+      expect(context.config.async).to be(false)
 
       Vero::App.init do |c|
         c.async = true
       end
-      context.config.async.should be_true
+      expect(context.config.async).to be(true)
     end
   end
 
   describe :disable_requests! do
-    it "should change config.disabled" do
+    it 'should change config.disabled' do
       Vero::App.init {}
-      context.config.disabled.should be_false
+      expect(context.config.disabled).to be(false)
 
       Vero::App.disable_requests!
-      context.config.disabled.should be_true            
+      expect(context.config.disabled).to be(true)
     end
   end
 
   describe :log do
-    it "should have a log method" do
+    it 'should have a log method' do
       Vero::App.init {}
-      Vero::App.should_receive(:log)
-      Vero::App.log(Object, "test")
+      expect(Vero::App).to receive(:log)
+      Vero::App.log(Object, 'test')
     end
   end
-end
+end

data/spec/lib/config_spec.rb

@@ -1,95 +1,113 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Vero::Config do
-  before :each do
-    @config = Vero::Config.new
-  end
+  let(:config) { Vero::Config.new }
 
-  it "should be async by default" do
-    @config.async.should be_true
+  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!
 
-      @config.reset!
-      @config.api_key.should be_nil
-      @config.secret.should be_nil
+      expect(config.api_key).to be_nil
+      expect(config.secret).to be_nil
     end
   end
 
   describe :auth_token do
-    it "should return nil if either api_key or secret are not set" do
-      @config.api_key = nil
-      @config.secret = "abcd"
-      @config.auth_token.should be_nil
-
-      @config.api_key = "abcd"
-      @config.secret = nil
-      @config.auth_token.should be_nil
-
-      @config.api_key = "abcd"
-      @config.secret = "abcd"
-      @config.auth_token.should_not be_nil
+    it 'should return nil if either api_key or secret are not set' do
+      config.api_key = nil
+      config.secret = 'abcd'
+      expect(config.auth_token).to be_nil
+
+      config.api_key = 'abcd'
+      config.secret = nil
+      expect(config.auth_token).to be_nil
+
+      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"
-      @config.auth_token.should == "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
-      @config.api_key = nil
-      @config.secret = nil
-      @config.development_mode = nil
-      @config.request_params.should == {}
-
-      @config.api_key = "abcd1234"
-      @config.secret = "abcd1234"
-      @config.request_params.should == {:auth_token => "YWJjZDEyMzQ6YWJjZDEyMzQ="}
-
-      @config.development_mode = true
-      @config.request_params.should == {:auth_token => "YWJjZDEyMzQ6YWJjZDEyMzQ=", :development_mode => true}
+    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.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
-      @config.domain.should == 'https://api.getvero.com'
-      @config.domain = 'blah.com'
-      @config.domain.should_not == 'https://api.getvero.com'
+    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
-      @config.domain = 'test.unbelieveable.com.au'
-      @config.domain.should == 'http://test.unbelieveable.com.au'
+    it 'should return the domain value' do
+      config.domain = 'test.unbelieveable.com.au'
+      expect(config.domain).to eq('http://test.unbelieveable.com.au')
 
-      @config.domain = 'http://test.unbelieveable.com.au'
-      @config.domain.should == 'http://test.unbelieveable.com.au'
+      config.domain = 'http://test.unbelieveable.com.au'
+      expect(config.domain).to eq('http://test.unbelieveable.com.au')
     end
   end
 
   describe :development_mode do
-    it "by default it should return true when Rails.env is either development or test" do
-      stub_env('development') {
+    it 'by default it should return false regardless of Rails environment' do
+      stub_env('development') do
         config = Vero::Config.new
-        config.development_mode.should be_true
-      }
+        expect(config.development_mode).to be(false)
+      end
 
-      stub_env('test') {
+      stub_env('test') do
         config = Vero::Config.new
-        config.development_mode.should be_true
-      }
+        expect(config.development_mode).to be(false)
+      end
 
-      stub_env('production') {
+      stub_env('production') do
         config = Vero::Config.new
-        config.development_mode.should be_false
-      }
+        expect(config.development_mode).to be(false)
+      end
+    end
+
+    it 'can be overritten with the config block' do
+      config.development_mode = true
+      expect(config.request_params[:development_mode]).to be(true)
+
+      config.reset!
+      expect(config.request_params[:development_mode]).to be(false)
+    end
+  end
+
+  describe :test_mode do
+    it 'should not raise error even though not configured properly' do
+      input = { event_name: 'test_event' }
+      mock_context = Vero::Context.new
+      allow(mock_context.config).to receive(:configured?).and_return(false)
+
+      expect { Vero::Api::Events.track!(input) }.to_not raise_error
     end
   end
-end
+end