analytics-ruby 2.0.13 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 71d4951f83fc43ae93e330b35c97062bd9c8df64
-  data.tar.gz: 11e299db5daf757cba620a539fd827dd25a8436d
+  metadata.gz: f272d5ddcbdd3fbded71fa72482a8d5b27679d9d
+  data.tar.gz: 70a98af711f968d00e0e7a68144afddb98fe00e5
 SHA512:
-  metadata.gz: 8439045c35184236fe21998035a6aa56b799b0d51246f7a52afc676511991eedb71001059ed81fc5f72f05debb1471ea4acc49cc9c4395f7844d010c35c9a95c
-  data.tar.gz: 3e5e394d1a0c569d37b8eccb85edc086ff6d7a94fb0eb8894764bafb57eaa01700ab7b2b64834052a17421e23b86396f8d9beca3fbcc67b824d6f2b4d615ea05
+  metadata.gz: 3e61136a5eb4d08866638bb0084e4fe9977d08f15a2498ce642335b2eed4f33adcefe0c53100924bee3b4774ede158a0a8fc8a149dd20e5b8e740198add41cf7
+  data.tar.gz: 8e93c453d66121654cb841da5937ac62409ba089b9c1d9cda708d7db1065b077a406d72198e2ba8b53f5dfacd8340271729c36bcd5d785692ab85f00f82ad645

data/Gemfile.lock

@@ -1,34 +1,34 @@
 PATH
   remote: .
   specs:
-    analytics-ruby (2.0.12)
+    analytics-ruby (2.0.13)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activesupport (3.2.21)
+    activesupport (3.2.22)
       i18n (~> 0.6, >= 0.6.4)
       multi_json (~> 1.0)
     diff-lcs (1.2.5)
     i18n (0.7.0)
-    multi_json (1.11.1)
+    multi_json (1.11.2)
     predicated (0.2.6)
     rake (10.4.2)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.8)
-    rspec-expectations (2.14.5)
+    rspec (2.99.0)
+      rspec-core (~> 2.99.0)
+      rspec-expectations (~> 2.99.0)
+      rspec-mocks (~> 2.99.0)
+    rspec-core (2.99.2)
+    rspec-expectations (2.99.2)
       diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.6)
-    ruby2ruby (2.1.0)
+    rspec-mocks (2.99.4)
+    ruby2ruby (2.2.0)
       ruby_parser (~> 3.1)
       sexp_processor (~> 4.0)
-    ruby_parser (3.6.1)
+    ruby_parser (3.7.2)
       sexp_processor (~> 4.1)
-    sexp_processor (4.4.3)
-    thread_safe (0.3.4)
+    sexp_processor (4.6.0)
+    thread_safe (0.3.5)
     tzinfo (1.2.1)
       thread_safe (~> 0.1)
     wrong (0.7.1)
@@ -50,4 +50,4 @@ DEPENDENCIES
   wrong (~> 0.0)
 
 BUNDLED WITH
-   1.10.6
+   1.11.2

data/History.md

@@ -1,3 +1,18 @@
+
+2.1.0 / 2016-06-17
+==================
+
+ * Fix: Ensure error handler is called before Client#flush finishes.
+ * Feature: Support setting a custom message ID.
+
+2.0.13 / 2015-09-15
+==================
+
+ * readme: updated install docs
+ * fix: page/screen to allow no name
+ * git: ignore ruby version
+ * travis-ci: remove old rubys
+
 2.0.12 / 2015-01-10
 ==================
 

data/Makefile

@@ -5,4 +5,4 @@ test:
 build:
 	gem build ./analytics-ruby.gemspec
 
-.PHONY: test
+.PHONY: test build

data/lib/segment/analytics.rb

@@ -10,7 +10,7 @@ require 'segment/analytics/logging'
 module Segment
   class Analytics
     def initialize options = {}
-      Request.stub = options[:stub]
+      Request.stub = options[:stub] if options.has_key?(:stub)
       @client = Segment::Analytics::Client.new options
     end
 

data/lib/segment/analytics/client.rb

@@ -52,6 +52,7 @@ module Segment
       #           :properties   - Hash of event properties. (optional)
       #           :timestamp    - Time of when the event occurred. (optional)
       #           :user_id      - String of the user id.
+      #           :message_id   - String of the message id that uniquely identified a message across the API. (optional)
       def track attrs
         symbolize_keys! attrs
         check_user_id! attrs
@@ -60,6 +61,7 @@ module Segment
         properties = attrs[:properties] || {}
         timestamp = attrs[:timestamp] || Time.new
         context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
 
         check_timestamp! timestamp
 
@@ -76,10 +78,11 @@ module Segment
           :event => event,
           :userId => attrs[:user_id],
           :anonymousId => attrs[:anonymous_id],
-          :context =>  context,
+          :context => context,
           :options => attrs[:options],
           :integrations => attrs[:integrations],
           :properties => properties,
+          :messageId => message_id,
           :timestamp => datetime_in_iso8601(timestamp),
           :type => 'track'
         })
@@ -95,6 +98,7 @@ module Segment
       #           :timestamp    - Time of when the event occurred. (optional)
       #           :traits       - Hash of user traits. (optional)
       #           :user_id      - String of the user id
+      #           :message_id   - String of the message id that uniquely identified a message across the API. (optional)
       def identify attrs
         symbolize_keys! attrs
         check_user_id! attrs
@@ -102,6 +106,7 @@ module Segment
         traits = attrs[:traits] || {}
         timestamp = attrs[:timestamp] || Time.new
         context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
 
         check_timestamp! timestamp
 
@@ -117,6 +122,7 @@ module Segment
           :context => context,
           :traits => traits,
           :options => attrs[:options],
+          :messageId => message_id,
           :timestamp => datetime_in_iso8601(timestamp),
           :type => 'identify'
         })
@@ -131,6 +137,7 @@ module Segment
       #           :previous_id - String of the id to alias from
       #           :timestamp   - Time of when the alias occured (optional)
       #           :user_id     - String of the id to alias to
+      #           :message_id   - String of the message id that uniquely identified a message across the API. (optional)
       def alias(attrs)
         symbolize_keys! attrs
 
@@ -138,6 +145,7 @@ module Segment
         to = attrs[:user_id]
         timestamp = attrs[:timestamp] || Time.new
         context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
 
         check_presence! from, 'previous_id'
         check_presence! to, 'user_id'
@@ -150,6 +158,7 @@ module Segment
           :integrations => attrs[:integrations],
           :context => context,
           :options => attrs[:options],
+          :messageId => message_id,
           :timestamp => datetime_in_iso8601(timestamp),
           :type => 'alias'
         })
@@ -164,6 +173,7 @@ module Segment
       #           :previous_id  - String of the id to alias from
       #           :timestamp    - Time of when the alias occured (optional)
       #           :user_id      - String of the id to alias to
+      #           :message_id   - String of the message id that uniquely identified a message across the API. (optional)
       def group(attrs)
         symbolize_keys! attrs
         check_user_id! attrs
@@ -173,6 +183,7 @@ module Segment
         traits = attrs[:traits] || {}
         timestamp = attrs[:timestamp] || Time.new
         context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
 
         fail ArgumentError, '.traits must be a hash' unless traits.is_a? Hash
         isoify_dates! traits
@@ -188,6 +199,7 @@ module Segment
           :integrations => attrs[:integrations],
           :options => attrs[:options],
           :context => context,
+          :messageId => message_id,
           :timestamp => datetime_in_iso8601(timestamp),
           :type => 'group'
         })
@@ -205,6 +217,7 @@ module Segment
       #           :properties   - Hash of page properties (optional)
       #           :timestamp    - Time of when the pageview occured (optional)
       #           :user_id      - String of the id to alias from
+      #           :message_id   - String of the message id that uniquely identified a message across the API. (optional)
       def page(attrs)
         symbolize_keys! attrs
         check_user_id! attrs
@@ -213,6 +226,7 @@ module Segment
         properties = attrs[:properties] || {}
         timestamp = attrs[:timestamp] || Time.new
         context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
 
         fail ArgumentError, '.properties must be a hash' unless properties.is_a? Hash
         isoify_dates! properties
@@ -229,6 +243,7 @@ module Segment
           :integrations => attrs[:integrations],
           :options => attrs[:options],
           :context => context,
+          :messageId => message_id,
           :timestamp => datetime_in_iso8601(timestamp),
           :type => 'page'
         })
@@ -253,6 +268,7 @@ module Segment
         properties = attrs[:properties] || {}
         timestamp = attrs[:timestamp] || Time.new
         context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
 
         fail ArgumentError, '.properties must be a hash' unless properties.is_a? Hash
         isoify_dates! properties
@@ -269,6 +285,7 @@ module Segment
           :options => attrs[:options],
           :integrations => attrs[:integrations],
           :context => context,
+          :messageId => message_id,
           :timestamp => timestamp.iso8601,
           :type => 'screen'
         })
@@ -288,7 +305,7 @@ module Segment
       # returns Boolean of whether the item was added to the queue.
       def enqueue(action)
         # add our request id for tracing purposes
-        action[:messageId] = uid
+        action[:messageId] ||= uid
         unless queue_full = @queue.length >= @max_queue_size
           ensure_worker_running
           @queue << action

data/lib/segment/analytics/version.rb

@@ -1,5 +1,5 @@
 module Segment
   class Analytics
-    VERSION = '2.0.13'
+    VERSION = '2.1.0'
   end
 end

data/lib/segment/analytics/worker.rb

@@ -44,9 +44,9 @@ module Segment
 
           res = Request.new.post @write_key, @batch
 
-          @lock.synchronize { @batch.clear }
-
           @on_error.call res.status, res.error unless res.status == 200
+
+          @lock.synchronize { @batch.clear }
         end
       end
 

data/spec/segment/analytics/client_spec.rb

@@ -3,37 +3,39 @@ require 'spec_helper'
 module Segment
   class Analytics
     describe Client do
+      let(:client) { Client.new :write_key => WRITE_KEY }
+      let(:queue) { client.instance_variable_get :@queue }
+
       describe '#initialize' do
-        it 'should error if no write_key is supplied' do
+        it 'errors if no write_key is supplied' do
           expect { Client.new }.to raise_error(ArgumentError)
         end
 
-        it 'should not error if a write_key is supplied' do
-          Client.new :write_key => WRITE_KEY
+        it 'does not error if a write_key is supplied' do
+          expect do
+            Client.new :write_key => WRITE_KEY
+          end.to_not raise_error
         end
 
-        it 'should not error if a write_key is supplied as a string' do
-          Client.new 'write_key' => WRITE_KEY
+        it 'does not error if a write_key is supplied as a string' do
+          expect do
+            Client.new 'write_key' => WRITE_KEY
+          end.to_not raise_error
         end
       end
 
       describe '#track' do
-        before(:all) do
-          @client = Client.new :write_key => WRITE_KEY
-          @queue = @client.instance_variable_get :@queue
-        end
-
-        it 'should error without an event' do
-          expect { @client.track(:user_id => 'user') }.to raise_error(ArgumentError)
+        it 'errors without an event' do
+          expect { client.track(:user_id => 'user') }.to raise_error(ArgumentError)
         end
 
-        it 'should error without a user_id' do
-          expect { @client.track(:event => 'Event') }.to raise_error(ArgumentError)
+        it 'errors without a user_id' do
+          expect { client.track(:event => 'Event') }.to raise_error(ArgumentError)
         end
 
-        it 'should error if properties is not a hash' do
+        it 'errors if properties is not a hash' do
           expect {
-            @client.track({
+            client.track({
               :user_id => 'user',
               :event => 'Event',
               :properties => [1,2,3]
@@ -41,32 +43,36 @@ module Segment
           }.to raise_error(ArgumentError)
         end
 
-        it 'should use the timestamp given' do
+        it 'uses the timestamp given' do
           time = Time.parse("1990-07-16 13:30:00.123 UTC")
 
-          @client.track({
+          client.track({
             :event => 'testing the timestamp',
             :user_id => 'joe',
             :timestamp => time
           })
 
-          msg = @queue.pop
+          msg = queue.pop
 
-          Time.parse(msg[:timestamp]).should == time
+          expect(Time.parse(msg[:timestamp])).to eq(time)
         end
 
-        it 'should not error with the required options' do
-          @client.track Queued::TRACK
-          @queue.pop
+        it 'does not error with the required options' do
+          expect do
+            client.track Queued::TRACK
+            queue.pop
+          end.to_not raise_error
         end
 
-        it 'should not error when given string keys' do
-          @client.track Utils.stringify_keys(Queued::TRACK)
-          @queue.pop
+        it 'does not error when given string keys' do
+          expect do
+            client.track Utils.stringify_keys(Queued::TRACK)
+            queue.pop
+          end.to_not raise_error
         end
 
-        it 'should convert time and date traits into iso8601 format' do
-          @client.track({
+        it 'converts time and date traits into iso8601 format' do
+          client.track({
             :user_id => 'user',
             :event => 'Event',
             :properties => {
@@ -77,38 +83,38 @@ module Segment
               :nottime => 'x'
             }
           })
-          message = @queue.pop
-          message[:properties][:time].should == '2013-01-01T00:00:00.000Z'
-          message[:properties][:time_with_zone].should == '2013-01-01T00:00:00.000Z'
-          message[:properties][:date_time].should == '2013-01-01T00:00:00.000Z'
-          message[:properties][:date].should == '2013-01-01'
-          message[:properties][:nottime].should == 'x'
+          message = queue.pop
+
+          expect(message[:properties][:time]).to eq('2013-01-01T00:00:00.000Z')
+          expect(message[:properties][:time_with_zone]).to eq('2013-01-01T00:00:00.000Z')
+          expect(message[:properties][:date_time]).to eq('2013-01-01T00:00:00.000Z')
+          expect(message[:properties][:date]).to eq('2013-01-01')
+          expect(message[:properties][:nottime]).to eq('x')
         end
       end
 
 
       describe '#identify' do
-        before(:all) do
-          @client = Client.new :write_key => WRITE_KEY
-          @queue = @client.instance_variable_get :@queue
+        it 'errors without any user id' do
+          expect { client.identify({}) }.to raise_error(ArgumentError)
         end
 
-        it 'should error without any user id' do
-          expect { @client.identify({}) }.to raise_error(ArgumentError)
+        it 'does not error with the required options' do
+          expect do
+            client.identify Queued::IDENTIFY
+            queue.pop
+          end.to_not raise_error
         end
 
-        it 'should not error with the required options' do
-          @client.identify Queued::IDENTIFY
-          @queue.pop
+        it 'does not error with the required options as strings' do
+          expect do
+            client.identify Utils.stringify_keys(Queued::IDENTIFY)
+            queue.pop
+          end.to_not raise_error
         end
 
-        it 'should not error with the required options as strings' do
-          @client.identify Utils.stringify_keys(Queued::IDENTIFY)
-          @queue.pop
-        end
-
-        it 'should convert time and date traits into iso8601 format' do
-          @client.identify({
+        it 'converts time and date traits into iso8601 format' do
+          client.identify({
             :user_id => 'user',
             :traits => {
               :time => Time.utc(2013),
@@ -118,65 +124,60 @@ module Segment
               :nottime => 'x'
             }
           })
-          message = @queue.pop
-          message[:traits][:time].should == '2013-01-01T00:00:00.000Z'
-          message[:traits][:time_with_zone].should == '2013-01-01T00:00:00.000Z'
-          message[:traits][:date_time].should == '2013-01-01T00:00:00.000Z'
-          message[:traits][:date].should == '2013-01-01'
-          message[:traits][:nottime].should == 'x'
+
+          message = queue.pop
+
+          expect(message[:traits][:time]).to eq('2013-01-01T00:00:00.000Z')
+          expect(message[:traits][:time_with_zone]).to eq('2013-01-01T00:00:00.000Z')
+          expect(message[:traits][:date_time]).to eq('2013-01-01T00:00:00.000Z')
+          expect(message[:traits][:date]).to eq('2013-01-01')
+          expect(message[:traits][:nottime]).to eq('x')
         end
       end
 
       describe '#alias' do
-        before :all do
-          @client = Client.new :write_key => WRITE_KEY
+        it 'errors without from' do
+          expect { client.alias :user_id => 1234 }.to raise_error(ArgumentError)
         end
 
-        it 'should error without from' do
-          expect { @client.alias :user_id => 1234 }.to raise_error(ArgumentError)
+        it 'errors without to' do
+          expect { client.alias :previous_id => 1234 }.to raise_error(ArgumentError)
         end
 
-        it 'should error without to' do
-          expect { @client.alias :previous_id => 1234 }.to raise_error(ArgumentError)
+        it 'does not error with the required options' do
+          expect { client.alias ALIAS }.to_not raise_error
         end
 
-        it 'should not error with the required options' do
-          @client.alias ALIAS
-        end
-
-        it 'should not error with the required options as strings' do
-          @client.alias Utils.stringify_keys(ALIAS)
+        it 'does not error with the required options as strings' do
+          expect do
+            client.alias Utils.stringify_keys(ALIAS)
+          end.to_not raise_error
         end
       end
 
       describe '#group' do
-        before :all do
-          @client = Client.new :write_key => WRITE_KEY
-          @queue = @client.instance_variable_get :@queue
-        end
-
-        after :each do
-          @client.flush
+        after do
+          client.flush
         end
 
-        it 'should error without group_id' do
-          expect { @client.group :user_id => 'foo' }.to raise_error(ArgumentError)
+        it 'errors without group_id' do
+          expect { client.group :user_id => 'foo' }.to raise_error(ArgumentError)
         end
 
-        it 'should error without user_id' do
-          expect { @client.group :group_id => 'foo' }.to raise_error(ArgumentError)
+        it 'errors without user_id' do
+          expect { client.group :group_id => 'foo' }.to raise_error(ArgumentError)
         end
 
-        it 'should not error with the required options' do
-          @client.group Queued::GROUP
+        it 'does not error with the required options' do
+          client.group Queued::GROUP
         end
 
-        it 'should not error with the required options as strings' do
-          @client.group Utils.stringify_keys(Queued::GROUP)
+        it 'does not error with the required options as strings' do
+          client.group Utils.stringify_keys(Queued::GROUP)
         end
 
-        it 'should convert time and date traits into iso8601 format' do
-          @client.identify({
+        it 'converts time and date traits into iso8601 format' do
+          client.identify({
             :user_id => 'user',
             :group_id => 'group',
             :traits => {
@@ -187,70 +188,65 @@ module Segment
               :nottime => 'x'
             }
           })
-          message = @queue.pop
-          message[:traits][:time].should == '2013-01-01T00:00:00.000Z'
-          message[:traits][:time_with_zone].should == '2013-01-01T00:00:00.000Z'
-          message[:traits][:date_time].should == '2013-01-01T00:00:00.000Z'
-          message[:traits][:date].should == '2013-01-01'
-          message[:traits][:nottime].should == 'x'
+
+          message = queue.pop
+
+          expect(message[:traits][:time]).to eq('2013-01-01T00:00:00.000Z')
+          expect(message[:traits][:time_with_zone]).to eq('2013-01-01T00:00:00.000Z')
+          expect(message[:traits][:date_time]).to eq('2013-01-01T00:00:00.000Z')
+          expect(message[:traits][:date]).to eq('2013-01-01')
+          expect(message[:traits][:nottime]).to eq('x')
         end
       end
 
       describe '#page' do
-        before :all do
-          @client = Client.new :write_key => WRITE_KEY
-        end
-
-        it 'should error without user_id' do
-          expect { @client.page :name => 'foo' }.to raise_error(ArgumentError)
+        it 'errors without user_id' do
+          expect { client.page :name => 'foo' }.to raise_error(ArgumentError)
         end
 
-        it 'should not error with the required options' do
-          @client.page Queued::PAGE
+        it 'does not error with the required options' do
+          expect { client.page Queued::PAGE }.to_not raise_error
         end
 
-        it 'should not error with the required options as strings' do
-          @client.page Utils.stringify_keys(Queued::PAGE)
+        it 'does not error with the required options as strings' do
+          expect do
+            client.page Utils.stringify_keys(Queued::PAGE)
+          end.to_not raise_error
         end
       end
 
       describe '#screen' do
-        before :all do
-          @client = Client.new :write_key => WRITE_KEY
+        it 'errors without user_id' do
+          expect { client.screen :name => 'foo' }.to raise_error(ArgumentError)
         end
 
-        it 'should error without user_id' do
-          expect { @client.screen :name => 'foo' }.to raise_error(ArgumentError)
+        it 'does not error with the required options' do
+          expect { client.screen Queued::SCREEN }.to_not raise_error
         end
 
-        it 'should not error with the required options' do
-          @client.screen Queued::SCREEN
-        end
-
-        it 'should not error with the required options as strings' do
-          @client.screen Utils.stringify_keys(Queued::SCREEN)
+        it 'does not error with the required options as strings' do
+          expect do
+            client.screen Utils.stringify_keys(Queued::SCREEN)
+          end.to_not raise_error
         end
       end
 
       describe '#flush' do
-        before(:all) do
-          @client = Client.new :write_key => WRITE_KEY
-        end
+        it 'waits for the queue to finish on a flush' do
+          client.identify Queued::IDENTIFY
+          client.track Queued::TRACK
+          client.flush
 
-        it 'should wait for the queue to finish on a flush' do
-          @client.identify Queued::IDENTIFY
-          @client.track Queued::TRACK
-          @client.flush
-          @client.queued_messages.should == 0
+          expect(client.queued_messages).to eq(0)
         end
 
-        it 'should complete when the process forks' do
-          @client.identify Queued::IDENTIFY
+        it 'completes when the process forks' do
+          client.identify Queued::IDENTIFY
 
           Process.fork do
-            @client.track Queued::TRACK
-            @client.flush
-            @client.queued_messages.should == 0
+            client.track Queued::TRACK
+            client.flush
+            expect(client.queued_messages).to eq(0)
           end
 
           Process.wait
@@ -258,31 +254,55 @@ module Segment
       end
 
       context 'common' do
-        check_property = proc { |msg, k, v| msg[k] && msg[k].should == v }
+        check_property = proc { |msg, k, v| msg[k] && msg[k] == v }
 
-        before(:all) do
-          @client = Client.new :write_key => WRITE_KEY
-          @queue = @client.instance_variable_get :@queue
-        end
+        let(:data) { { :user_id => 1, :group_id => 2, :previous_id => 3, :anonymous_id => 4, :message_id => 5, :event => "coco barked", :name => "coco" } }
 
+        it 'does not convert ids given as fixnums to strings' do
+          [:track, :screen, :page, :identify].each do |s|
+            client.send(s, data)
+            message = queue.pop(true)
 
-        it 'should not convert ids given as fixnums to strings' do
+            expect(check_property.call(message, :userId, 1)).to eq(true)
+            expect(check_property.call(message, :anonymousId, 4)).to eq(true)
+          end
+        end
+
+        it 'converts message id to string' do
           [:track, :screen, :page, :group, :identify, :alias].each do |s|
-            @client.send s, :user_id => 1, :group_id => 2, :previous_id => 3, :anonymous_id => 4, :event => "coco barked", :name => "coco"
-            message = @queue.pop(true)
-            check_property.call(message, :userId, 1)
-            check_property.call(message, :groupId, 2)
-            check_property.call(message, :previousId, 3)
-            check_property.call(message, :anonymousId, 4)
+            client.send(s, data)
+            message = queue.pop(true)
+
+            expect(check_property.call(message, :messageId, '5')).to eq(true)
+          end
+        end
+
+        context 'group' do
+          it 'does not convert ids given as fixnums to strings' do
+            client.group(data)
+            message = queue.pop(true)
+
+            expect(check_property.call(message, :userId, 1)).to eq(true)
+            expect(check_property.call(message, :groupId, 2)).to eq(true)
+          end
+        end
+
+        context 'alias' do
+          it 'does not convert ids given as fixnums to strings' do
+            client.alias(data)
+            message = queue.pop(true)
+
+            expect(check_property.call(message, :userId, 1)).to eq(true)
+            expect(check_property.call(message, :previousId, 3)).to eq(true)
           end
         end
 
-        it 'should send integrations' do
+        it 'sends integrations' do
           [:track, :screen, :page, :group, :identify, :alias].each do |s|
-            @client.send s, :integrations => { :All => true, :Salesforce => false }, :user_id => 1, :group_id => 2, :previous_id => 3, :anonymous_id => 4, :event => "coco barked", :name => "coco"
-            message = @queue.pop(true)
-            message[:integrations][:All].should be_true
-            message[:integrations][:Salesforce].should be_false
+            client.send s, :integrations => { :All => true, :Salesforce => false }, :user_id => 1, :group_id => 2, :previous_id => 3, :anonymous_id => 4, :event => "coco barked", :name => "coco"
+            message = queue.pop(true)
+            expect(message[:integrations][:All]).to eq(true)
+            expect(message[:integrations][:Salesforce]).to eq(false)
           end
         end
       end