tweetstream 2.5.0 → 2.6.0

data/spec/tweetstream/client_authentication_spec.rb

@@ -2,7 +2,7 @@ require 'helper'
 
 describe TweetStream::Client do
   before do
-    @stream = stub("EM::Twitter::Client",
+    @stream = double("EM::Twitter::Client",
       :connect => true,
       :unbind => true,
       :each => true,
@@ -14,8 +14,8 @@ describe TweetStream::Client do
       :on_unauthorized => true,
       :on_enhance_your_calm => true
     )
-    EM.stub!(:run).and_yield
-    EM::Twitter::Client.stub!(:connect).and_return(@stream)
+    allow(EM).to receive(:run).and_yield
+    allow(EM::Twitter::Client).to receive(:connect).and_return(@stream)
   end
 
   describe "basic auth" do
@@ -30,7 +30,7 @@ describe TweetStream::Client do
     end
 
     it "tries to connect via a JSON stream with basic auth" do
-      EM::Twitter::Client.should_receive(:connect).with(
+      expect(EM::Twitter::Client).to receive(:connect).with(
         :path => '/1.1/statuses/filter.json',
         :method => 'POST',
         :user_agent => TweetStream::Configuration::DEFAULT_USER_AGENT,
@@ -61,7 +61,7 @@ describe TweetStream::Client do
     end
 
     it "tries to connect via a JSON stream with oauth" do
-      EM::Twitter::Client.should_receive(:connect).with(
+      expect(EM::Twitter::Client).to receive(:connect).with(
         :path => '/1.1/statuses/filter.json',
         :method => 'POST',
         :user_agent => TweetStream::Configuration::DEFAULT_USER_AGENT,

data/spec/tweetstream/client_site_stream_spec.rb

@@ -10,7 +10,7 @@ describe TweetStream::Client do
     end
     @client = TweetStream::Client.new
 
-    @stream = stub("EM::Twitter::Client",
+    @stream = double("EM::Twitter::Client",
       :connect => true,
       :unbind => true,
       :each => true,
@@ -22,39 +22,39 @@ describe TweetStream::Client do
       :on_unauthorized => true,
       :on_enhance_your_calm => true
     )
-    EM.stub!(:run).and_yield
-    EM::Twitter::Client.stub!(:connect).and_return(@stream)
+    allow(EM).to receive(:run).and_yield
+    allow(EM::Twitter::Client).to receive(:connect).and_return(@stream)
   end
 
   describe "Site Stream support" do
     context "when calling #sitestream" do
       it "sends the sitestream host" do
-        EM::Twitter::Client.should_receive(:connect).with(hash_including(:host => "sitestream.twitter.com")).and_return(@stream)
+        expect(EM::Twitter::Client).to receive(:connect).with(hash_including(:host => "sitestream.twitter.com")).and_return(@stream)
         @client.sitestream
       end
 
       it "uses the sitestream uri" do
-        @client.should_receive(:start).once.with('/1.1/site.json', an_instance_of(Hash)).and_return(@stream)
+        expect(@client).to receive(:start).once.with('/1.1/site.json', an_instance_of(Hash)).and_return(@stream)
         @client.sitestream
       end
 
       it "supports :followings => true" do
-        @client.should_receive(:start).once.with('/1.1/site.json', hash_including(:with => 'followings')).and_return(@stream)
+        expect(@client).to receive(:start).once.with('/1.1/site.json', hash_including(:with => 'followings')).and_return(@stream)
         @client.sitestream(['115192457'], :followings => true)
       end
 
       it "supports :with => 'followings'" do
-        @client.should_receive(:start).once.with('/1.1/site.json', hash_including(:with => 'followings')).and_return(@stream)
+        expect(@client).to receive(:start).once.with('/1.1/site.json', hash_including(:with => 'followings')).and_return(@stream)
         @client.sitestream(['115192457'], :with => 'followings')
       end
 
       it "supports :with => 'user'" do
-        @client.should_receive(:start).once.with('/1.1/site.json', hash_including(:with => 'user')).and_return(@stream)
+        expect(@client).to receive(:start).once.with('/1.1/site.json', hash_including(:with => 'user')).and_return(@stream)
         @client.sitestream(['115192457'], :with => 'user')
       end
 
       it "supports :replies => 'all'" do
-        @client.should_receive(:start).once.with('/1.1/site.json', hash_including(:replies => 'all')).and_return(@stream)
+        expect(@client).to receive(:start).once.with('/1.1/site.json', hash_including(:replies => 'all')).and_return(@stream)
         @client.sitestream(['115192457'], :replies => 'all')
       end
 
@@ -67,14 +67,30 @@ describe TweetStream::Client do
           }
         end
         it "assigns the control_uri" do
-          @stream.should_receive(:each).and_yield(@control_response.to_json)
+          expect(@stream).to receive(:each).and_yield(@control_response.to_json)
           @client.sitestream
 
           expect(@client.control_uri).to eq("/1.1/site/c/01_225167_334389048B872A533002B34D73F8C29FD09EFC50")
         end
 
+        it 'invokes the on_control callback' do
+          called = false
+          expect(@stream).to receive(:each).and_yield(@control_response.to_json)
+          @client.on_control { called = true }
+          @client.sitestream
+
+          expect(called).to be_true
+        end
+
+        it 'is controllable when a control_uri has been received' do
+          expect(@stream).to receive(:each).and_yield(@control_response.to_json)
+          @client.sitestream
+
+          expect(@client.controllable?).to be_true
+        end
+
         it "instantiates a SiteStreamClient" do
-          @stream.should_receive(:each).and_yield(@control_response.to_json)
+          expect(@stream).to receive(:each).and_yield(@control_response.to_json)
           @client.sitestream
 
           expect(@client.control).to be_kind_of(TweetStream::SiteStreamClient)
@@ -83,7 +99,7 @@ describe TweetStream::Client do
         it "passes the client's on_error to the SiteStreamClient" do
           called = false
           @client.on_error { |err| called = true }
-          @stream.should_receive(:each).and_yield(@control_response.to_json)
+          expect(@stream).to receive(:each).and_yield(@control_response.to_json)
           @client.sitestream
 
           @client.control.on_error.call
@@ -99,7 +115,7 @@ describe TweetStream::Client do
           end
 
           it "yields a site stream message" do
-            @stream.should_receive(:each).and_yield(@ss_message.to_json)
+            expect(@stream).to receive(:each).and_yield(@ss_message.to_json)
             yielded_status = nil
             @client.sitestream do |message|
               yielded_status = message
@@ -110,7 +126,7 @@ describe TweetStream::Client do
             expect(yielded_status[:message][:text]).to eq('Oo oo aa aa')
           end
           it "yields itself if block has an arity of 2" do
-            @stream.should_receive(:each).and_yield(@ss_message.to_json)
+            expect(@stream).to receive(:each).and_yield(@ss_message.to_json)
             yielded_client = nil
             @client.sitestream do |_, client|
               yielded_client = client
@@ -126,7 +142,7 @@ describe TweetStream::Client do
          end
 
           it "yields a friends list array" do
-            @stream.should_receive(:each).and_yield(@friends_list.to_json)
+            expect(@stream).to receive(:each).and_yield(@friends_list.to_json)
             yielded_list = nil
             @client.on_friends do |friends|
               yielded_list = friends

data/spec/tweetstream/client_spec.rb

@@ -13,7 +13,7 @@ describe TweetStream::Client do
 
   describe "#start" do
     before do
-      @stream = stub("EM::Twitter::Client",
+      @stream = double("EM::Twitter::Client",
         :connect => true,
         :unbind => true,
         :each => true,
@@ -25,33 +25,33 @@ describe TweetStream::Client do
         :on_unauthorized => true,
         :on_enhance_your_calm => true
       )
-      EM.stub!(:run).and_yield
-      EM::Twitter::Client.stub!(:connect).and_return(@stream)
+      allow(EM).to receive(:run).and_yield
+      allow(EM::Twitter::Client).to receive(:connect).and_return(@stream)
     end
 
     it "connects if the reactor is already running" do
-      EM.stub!(:reactor_running?).and_return(true)
-      @client.should_receive(:connect)
+      allow(EM).to receive(:reactor_running?).and_return(true)
+      expect(@client).to receive(:connect)
       @client.track('abc')
     end
 
     it "starts the reactor if not already running" do
-      EM.should_receive(:run).once
+      expect(EM).to receive(:run).once
       @client.track('abc')
     end
 
     it "warns when callbacks are passed as options" do
-      @stream.stub(:each).and_yield(nil)
-      Kernel.should_receive(:warn).with(/Passing callbacks via the options hash is deprecated and will be removed in TweetStream 3.0/)
+      allow(@stream).to receive(:each).and_return
+      expect(Kernel).to receive(:warn).with(/Passing callbacks via the options hash is deprecated and will be removed in TweetStream 3.0/)
       @client.track('abc', :inited => Proc.new { })
     end
 
     describe 'proxy usage' do
       it 'connects with a proxy' do
         @client = TweetStream::Client.new(:proxy => { :uri => 'http://someproxy:8081'})
-        EM::Twitter::Client.should_receive(:connect).
+        expect(EM::Twitter::Client).to receive(:connect).
           with(hash_including(:proxy => { :uri => 'http://someproxy:8081'})).and_return(@stream)
-        @stream.should_receive(:each).and_return
+        expect(@stream).to receive(:each).and_return
         @client.track('abc')
       end
     end
@@ -59,18 +59,18 @@ describe TweetStream::Client do
     describe "#each" do
       it "calls the appropriate parser" do
         @client = TweetStream::Client.new
-        Yajl::Parser.should_receive(:parse).twice.and_return({})
-        @stream.should_receive(:each).and_yield(sample_tweets[0].to_json)
+        expect(MultiJson).to receive(:decode).and_return({})
+        expect(@stream).to receive(:each).and_yield(sample_tweets[0].to_json)
         @client.track('abc','def')
       end
 
       it "yields a Twitter::Tweet" do
-        @stream.should_receive(:each).and_yield(sample_tweets[0].to_json)
+        expect(@stream).to receive(:each).and_yield(sample_tweets[0].to_json)
         @client.track('abc'){|s| expect(s).to be_kind_of(Twitter::Tweet)}
       end
 
       it "yields the client if a block with arity 2 is given" do
-        @stream.should_receive(:each).and_yield(sample_tweets[0].to_json)
+        expect(@stream).to receive(:each).and_yield(sample_tweets[0].to_json)
         @client.track('abc'){|s,c| expect(c).to eq(@client)}
       end
 
@@ -79,7 +79,7 @@ describe TweetStream::Client do
         tweet[:id] = 123
         tweet[:user][:screen_name] = 'monkey'
         tweet[:text] = "Oo oo aa aa"
-        @stream.should_receive(:each).and_yield(tweet.to_json)
+        expect(@stream).to receive(:each).and_yield(tweet.to_json)
         @client.track('abc') do |s|
           expect(s[:id]).to eq(123)
           expect(s.user.screen_name).to eq('monkey')
@@ -88,14 +88,14 @@ describe TweetStream::Client do
       end
 
       it "calls the on_stall_warning callback if specified" do
-        @stream.should_receive(:each).and_yield(fixture('stall_warning.json'))
+        expect(@stream).to receive(:each).and_yield(fixture('stall_warning.json'))
         @client.on_stall_warning do |warning|
           expect(warning[:code]).to eq('FALLING_BEHIND')
         end.track('abc')
       end
 
       it "calls the on_scrub_geo callback if specified" do
-        @stream.should_receive(:each).and_yield(fixture('scrub_geo.json'))
+        expect(@stream).to receive(:each).and_yield(fixture('scrub_geo.json'))
         @client.on_scrub_geo do |up_to_status_id, user_id|
           expect(up_to_status_id).to eq(9876)
           expect(user_id).to eq(1234)
@@ -103,7 +103,7 @@ describe TweetStream::Client do
       end
 
       it "calls the on_delete callback" do
-        @stream.should_receive(:each).and_yield(fixture('delete.json'))
+        expect(@stream).to receive(:each).and_yield(fixture('delete.json'))
         @client.on_delete do |id, user_id|
           expect(id).to eq(1234)
           expect(user_id).to eq(3)
@@ -112,7 +112,7 @@ describe TweetStream::Client do
 
       it "calls the on_limit callback" do
         limit = nil
-        @stream.should_receive(:each).and_yield(fixture('limit.json'))
+        expect(@stream).to receive(:each).and_yield(fixture('limit.json'))
         @client.on_limit do |l|
           limit = l
         end.track('abc')
@@ -122,7 +122,7 @@ describe TweetStream::Client do
 
       it "calls the on_status_withheld callback" do
         status = nil
-        @stream.should_receive(:each).and_yield(fixture('status_withheld.json'))
+        expect(@stream).to receive(:each).and_yield(fixture('status_withheld.json'))
         @client.on_status_withheld do |s|
           status = s
         end.track('abc')
@@ -132,7 +132,7 @@ describe TweetStream::Client do
 
       it "calls the on_user_withheld callback" do
         status = nil
-        @stream.should_receive(:each).and_yield(fixture('user_withheld.json'))
+        expect(@stream).to receive(:each).and_yield(fixture('user_withheld.json'))
         @client.on_user_withheld do |s|
           status = s
         end.track('abc')
@@ -143,7 +143,7 @@ describe TweetStream::Client do
       context "using on_anything" do
         it "yields the raw hash" do
           hash = {:id => 1234}
-          @stream.should_receive(:each).and_yield(hash.to_json)
+          expect(@stream).to receive(:each).and_yield(hash.to_json)
           yielded_hash = nil
           @client.on_anything do |h|
             yielded_hash = h
@@ -154,7 +154,7 @@ describe TweetStream::Client do
         end
         it "yields itself if block has an arity of 2" do
           hash = {:id => 1234}
-          @stream.should_receive(:each).and_yield(hash.to_json)
+          expect(@stream).to receive(:each).and_yield(hash.to_json)
           yielded_client = nil
           @client.on_anything do |_, client|
             yielded_client = client
@@ -170,7 +170,7 @@ describe TweetStream::Client do
           tweet[:id] = 123
           tweet[:user][:screen_name] = 'monkey'
           tweet[:text] = "Oo oo aa aa"
-          @stream.should_receive(:each).and_yield(tweet.to_json)
+          expect(@stream).to receive(:each).and_yield(tweet.to_json)
           yielded_status = nil
           @client.on_timeline_status do |status|
             yielded_status = status
@@ -181,7 +181,7 @@ describe TweetStream::Client do
           expect(yielded_status.text).to eq('Oo oo aa aa')
         end
         it "yields itself if block has an arity of 2" do
-          @stream.should_receive(:each).and_yield(sample_tweets[0].to_json)
+          expect(@stream).to receive(:each).and_yield(sample_tweets[0].to_json)
           yielded_client = nil
           @client.on_timeline_status do |_, client|
             yielded_client = client
@@ -196,7 +196,7 @@ describe TweetStream::Client do
           direct_message = sample_direct_messages[0]
           direct_message[:direct_message][:id] = 1234
           direct_message[:direct_message][:sender][:screen_name] = "coder"
-          @stream.should_receive(:each).and_yield(direct_message.to_json)
+          expect(@stream).to receive(:each).and_yield(direct_message.to_json)
           yielded_dm = nil
           @client.on_direct_message do |dm|
             yielded_dm = dm
@@ -207,7 +207,7 @@ describe TweetStream::Client do
         end
 
         it "yields itself if block has an arity of 2" do
-          @stream.should_receive(:each).and_yield(sample_direct_messages[0].to_json)
+          expect(@stream).to receive(:each).and_yield(sample_direct_messages[0].to_json)
           yielded_client = nil
           @client.on_direct_message do |_, client|
             yielded_client = client
@@ -217,23 +217,23 @@ describe TweetStream::Client do
       end
 
       it "calls on_error if a non-hash response is received" do
-        @stream.should_receive(:each).and_yield('["favorited"]')
+        expect(@stream).to receive(:each).and_yield('["favorited"]')
         @client.on_error do |message|
           expect(message).to eq('Unexpected JSON object in stream: ["favorited"]')
         end.track('abc')
       end
 
       it "calls on_error if a json parse error occurs" do
-        @stream.should_receive(:each).and_yield("{'a_key':}")
+        expect(@stream).to receive(:each).and_yield("{'a_key':}")
         @client.on_error do |message|
-          expect(message).to eq("Yajl::ParseError occured in stream: {'a_key':}")
+          expect(message).to eq("MultiJson::DecodeError occured in stream: {'a_key':}")
         end.track('abc')
       end
     end
 
     describe "#on_error" do
       it "passes the message on to the error block" do
-        @stream.should_receive(:on_error).and_yield('Uh oh')
+        expect(@stream).to receive(:on_error).and_yield('Uh oh')
         @client.on_error do |m|
           expect(m).to eq('Uh oh')
         end.track('abc')
@@ -251,7 +251,7 @@ describe TweetStream::Client do
 
     describe "#on_max_reconnects" do
       it "raises a ReconnectError" do
-        @stream.should_receive(:on_max_reconnects).and_yield(30, 20)
+        expect(@stream).to receive(:on_max_reconnects).and_yield(30, 20)
         expect(lambda{ @client.track('abc') }).to raise_error(TweetStream::ReconnectError, "Failed to reconnect after 20 tries.")
       end
     end
@@ -260,64 +260,64 @@ describe TweetStream::Client do
   describe "API methods" do
     %w(firehose retweet sample links).each do |method|
       it "##{method} should make a call to start with \"statuses/#{method}\"" do
-        @client.should_receive(:start).once.with('/1.1/statuses/' + method + '.json', {})
+        expect(@client).to receive(:start).once.with('/1.1/statuses/' + method + '.json', {})
         @client.send(method)
       end
     end
 
     describe "#filter" do
       it "makes a call to 'statuses/filter' with the query params provided" do
-        @client.should_receive(:start).once.with('/1.1/statuses/filter.json', :follow => 123, :method => :post)
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :follow => 123, :method => :post)
         @client.filter(:follow => 123)
       end
       it "makes a call to 'statuses/filter' with the query params provided longitude/latitude pairs, separated by commas " do
-        @client.should_receive(:start).once.with('/1.1/statuses/filter.json', :locations => '-122.75,36.8,-121.75,37.8,-74,40,-73,41', :method => :post)
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :locations => '-122.75,36.8,-121.75,37.8,-74,40,-73,41', :method => :post)
         @client.filter(:locations => '-122.75,36.8,-121.75,37.8,-74,40,-73,41')
       end
     end
 
     describe "#follow" do
       it "makes a call to start with 'statuses/filter' and a follow query parameter" do
-        @client.should_receive(:start).once.with('/1.1/statuses/filter.json', :follow => [123], :method => :post)
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :follow => [123], :method => :post)
         @client.follow(123)
       end
 
       it "comma-joins multiple arguments" do
-        @client.should_receive(:start).once.with('/1.1/statuses/filter.json', :follow => [123,456], :method => :post)
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :follow => [123,456], :method => :post)
         @client.follow(123, 456)
       end
     end
 
     describe "#locations" do
       it "calls #start with 'statuses/filter' with the query params provided longitude/latitude pairs" do
-        @client.should_receive(:start).once.with('/1.1/statuses/filter.json', :locations => ['-122.75,36.8,-121.75,37.8,-74,40,-73,41'], :method => :post)
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :locations => ['-122.75,36.8,-121.75,37.8,-74,40,-73,41'], :method => :post)
         @client.locations('-122.75,36.8,-121.75,37.8,-74,40,-73,41')
       end
 
       it "calls #start with 'statuses/filter' with the query params provided longitude/latitude pairs and additional filter" do
-        @client.should_receive(:start).once.with('/1.1/statuses/filter.json', :locations => ['-122.75,36.8,-121.75,37.8,-74,40,-73,41'], :track => 'rock', :method => :post)
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :locations => ['-122.75,36.8,-121.75,37.8,-74,40,-73,41'], :track => 'rock', :method => :post)
         @client.locations('-122.75,36.8,-121.75,37.8,-74,40,-73,41', :track => 'rock')
       end
     end
 
     describe "#track" do
       it "makes a call to start with 'statuses/filter' and a track query parameter" do
-        @client.should_receive(:start).once.with('/1.1/statuses/filter.json', :track => ['test'], :method => :post)
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :track => ['test'], :method => :post)
         @client.track('test')
       end
 
       it "comma-joins multiple arguments" do
-        @client.should_receive(:start).once.with('/1.1/statuses/filter.json', :track => ['foo', 'bar', 'baz'], :method => :post)
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :track => ['foo', 'bar', 'baz'], :method => :post)
         @client.track('foo', 'bar', 'baz')
       end
 
       it "comma-joins an array of arguments" do
-        @client.should_receive(:start).once.with('/1.1/statuses/filter.json', :track => [['foo','bar','baz']], :method => :post)
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :track => [['foo','bar','baz']], :method => :post)
         @client.track(['foo','bar','baz'])
       end
 
       it "calls #start with 'statuses/filter' and the provided queries" do
-        @client.should_receive(:start).once.with('/1.1/statuses/filter.json', :track => ['rock'], :method => :post)
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :track => ['rock'], :method => :post)
         @client.track('rock')
       end
     end
@@ -339,12 +339,12 @@ describe TweetStream::Client do
 
   describe "#stop" do
     it "calls EventMachine::stop_event_loop" do
-      EventMachine.should_receive :stop_event_loop
+      expect(EventMachine).to receive(:stop_event_loop)
       expect(TweetStream::Client.new.stop).to be_nil
     end
 
     it "returns the last status yielded" do
-      EventMachine.should_receive :stop_event_loop
+      expect(EventMachine).to receive(:stop_event_loop)
       client = TweetStream::Client.new
       client.send(:instance_variable_set, :@last_status, {})
       expect(client.stop).to eq({})
@@ -353,14 +353,14 @@ describe TweetStream::Client do
 
   describe "#close_connection" do
     it "does not call EventMachine::stop_event_loop" do
-      EventMachine.should_not_receive :stop_event_loop
+      expect(EventMachine).not_to receive(:stop_event_loop)
       expect(TweetStream::Client.new.close_connection).to be_nil
     end
   end
 
   describe "#stop_stream" do
     before(:each) do
-      @stream = stub("EM::Twitter::Client",
+      @stream = double("EM::Twitter::Client",
         :connect => true,
         :unbind => true,
         :each => true,
@@ -373,18 +373,18 @@ describe TweetStream::Client do
         :on_enhance_your_calm => true,
         :stop => true
       )
-      EM::Twitter::Client.stub!(:connect).and_return(@stream)
+      allow(EM::Twitter::Client).to receive(:connect).and_return(@stream)
       @client = TweetStream::Client.new
       @client.connect('/')
     end
 
     it "calls stream.stop to cleanly stop the current stream" do
-      @stream.should_receive(:stop)
+      expect(@stream).to receive(:stop)
       @client.stop_stream
     end
 
     it "does not stop eventmachine" do
-      EventMachine.should_not_receive :stop_event_loop
+      expect(EventMachine).not_to receive(:stop_event_loop)
       @client.stop_stream
     end
   end