vero 0.8.1 → 0.9.0

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

@@ -1,16 +1,12 @@
 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' }}
@@ -21,15 +17,15 @@ describe Vero::Api::Workers::Users::EditAPI do
 
   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)
+      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)
+      allow(RestClient).to receive(:put).and_return(200)
       expect { subject.perform }.to_not raise_error
     end
   end

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

@@ -1,22 +1,17 @@
 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 => []}
       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 => []}
       subject.options = options
@@ -27,21 +22,21 @@ describe Vero::Api::Workers::Users::EditTagsAPI 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" }
 
       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'}
 
       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
@@ -60,15 +55,15 @@ describe Vero::Api::Workers::Users::EditTagsAPI do
 
   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)
+      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)
+      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,16 +1,12 @@
 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'}
@@ -20,26 +16,26 @@ describe Vero::Api::Workers::Users::ReidentifyAPI do
 
     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
+      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
+      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)
+      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)
+      allow(RestClient).to receive(:put).and_return(200)
       expect { subject.perform }.to_not raise_error
     end
   end

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

@@ -0,0 +1,29 @@
+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
+      RestClient.should_receive(:post).with("https://api.getvero.com/api/v2/users/resubscribe.json", {:auth_token => 'abcd', :id => '1234'})
+      RestClient.stub(:post).and_return(200)
+      subject.send(:request)
+    end
+  end
+end

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

@@ -1,21 +1,17 @@
 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}
       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'}
       subject.options = options
@@ -23,7 +19,7 @@ describe Vero::Api::Workers::Users::TrackAPI do
 
       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}
       subject.options = options
@@ -33,7 +29,7 @@ describe Vero::Api::Workers::Users::TrackAPI do
     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}
       subject.options = options
@@ -53,15 +49,15 @@ describe Vero::Api::Workers::Users::TrackAPI do
 
   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)
+      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)
+      allow(RestClient).to receive(:post).and_return(200)
       expect { subject.perform }.to_not raise_error
     end
   end

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

@@ -1,16 +1,12 @@
 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' }}
@@ -21,15 +17,15 @@ describe Vero::Api::Workers::Users::UnsubscribeAPI do
 
   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)
+      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)
+      allow(RestClient).to receive(:post).and_return(200)
       expect { subject.perform }.to_not raise_error
     end
   end

data/spec/lib/api_spec.rb

@@ -9,13 +9,13 @@ describe Vero::Api::Events do
       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")
-      mock_context.config.stub(:development_mode).and_return(true)
+      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
@@ -23,76 +23,69 @@ 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")
-      mock_context.config.stub(:development_mode).and_return(true)
-
-      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")
-      mock_context.config.stub(:development_mode).and_return(true)
-
-      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.com", :changes => {:age => 25}} }
 
-      Vero::Sender.should_receive(:send).with(Vero::Api::Workers::Users::EditAPI, true, "https://api.getvero.com", expected)
-
-      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)
-
-      mock_context = Vero::Context.new
-      mock_context.config.stub(:configured?).and_return(true)
-      mock_context.config.stub(:auth_token).and_return("abc123")
-      mock_context.config.stub(:development_mode).and_return(true)
-
-      Vero::App.stub(:default_context).and_return(mock_context)
+    context "should call the TrackAPI object via the configured sender" do
+      let(:input) { {:add => ["boom"], :remove => ["tish"]} }
 
-      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 => false)
-
-      mock_context = Vero::Context.new
-      mock_context.config.stub(:configured?).and_return(true)
-      mock_context.config.stub(:auth_token).and_return("abc123")
+    context "should call the TrackAPI object via the configured sender" do
+      let(:input) { {:email => "james@getvero"} }
 
-      Vero::App.stub(:default_context).and_return(mock_context)
+      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
 
-      Vero::Sender.should_receive(:send).with(Vero::Api::Workers::Users::UnsubscribeAPI, true, "https://api.getvero.com", expected)
+  describe :resubscribe! do
+    context "should call the TrackAPI object via the configured sender" do
+      let(:input) { {:email => "james@getvero"} }
 
-      subject.unsubscribe!(input)
+      specify do
+        Vero::Sender.should_receive(:send).with(Vero::Api::Workers::Users::ResubscribeAPI, true, "https://api.getvero.com", expected)
+        subject.resubscribe!(input)
+      end
     end
   end
 end

data/spec/lib/app_spec.rb

@@ -4,7 +4,7 @@ describe Vero::App do
   describe 'self.default_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
 
@@ -12,46 +12,46 @@ describe Vero::App do
   describe :init 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
       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"
       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
       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
       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
       Vero::App.init {}
-      Vero::App.should_receive(:log)
+      expect(Vero::App).to receive(:log)
       Vero::App.log(Object, "test")
     end
   end