tweetstream 2.6.0 → 2.6.1

data/spec/tweetstream/client_site_stream_spec.rb

@@ -10,35 +10,35 @@ describe TweetStream::Client do
     end
     @client = TweetStream::Client.new
 
-    @stream = double("EM::Twitter::Client",
-      :connect => true,
-      :unbind => true,
-      :each => true,
-      :on_error => true,
-      :on_max_reconnects => true,
-      :on_reconnect => true,
-      :connection_completed => true,
-      :on_no_data_received => true,
-      :on_unauthorized => true,
-      :on_enhance_your_calm => true
+    @stream = double('EM::Twitter::Client',
+                     :connect => true,
+                     :unbind => true,
+                     :each => true,
+                     :on_error => true,
+                     :on_max_reconnects => true,
+                     :on_reconnect => true,
+                     :connection_completed => true,
+                     :on_no_data_received => true,
+                     :on_unauthorized => true,
+                     :on_enhance_your_calm => true
     )
     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
-        expect(EM::Twitter::Client).to receive(:connect).with(hash_including(:host => "sitestream.twitter.com")).and_return(@stream)
+  describe 'Site Stream support' do
+    context 'when calling #sitestream' do
+      it 'sends the sitestream host' do
+        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
+      it 'uses the sitestream uri' do
         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
+      it 'supports :followings => true' do
         expect(@client).to receive(:start).once.with('/1.1/site.json', hash_including(:with => 'followings')).and_return(@stream)
         @client.sitestream(['115192457'], :followings => true)
       end
@@ -58,19 +58,19 @@ describe TweetStream::Client do
         @client.sitestream(['115192457'], :replies => 'all')
       end
 
-      describe "control management" do
+      describe 'control management' do
         before do
-          @control_response = {"control" =>
+          @control_response = {'control' =>
             {
-              "control_uri" =>"/1.1/site/c/01_225167_334389048B872A533002B34D73F8C29FD09EFC50"
+              'control_uri' => '/1.1/site/c/01_225167_334389048B872A533002B34D73F8C29FD09EFC50'
             }
           }
         end
-        it "assigns the control_uri" do
+        it 'assigns the control_uri' do
           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")
+          expect(@client.control_uri).to eq('/1.1/site/c/01_225167_334389048B872A533002B34D73F8C29FD09EFC50')
         end
 
         it 'invokes the on_control callback' do
@@ -89,7 +89,7 @@ describe TweetStream::Client do
           expect(@client.controllable?).to be_true
         end
 
-        it "instantiates a SiteStreamClient" do
+        it 'instantiates a SiteStreamClient' do
           expect(@stream).to receive(:each).and_yield(@control_response.to_json)
           @client.sitestream
 
@@ -108,24 +108,24 @@ describe TweetStream::Client do
         end
       end
 
-      describe "data handling" do
-        context "messages" do
+      describe 'data handling' do
+        context 'messages' do
           before do
-            @ss_message = {'for_user' => '12345', 'message' => {'id' => 123, 'user' => {'screen_name' => 'monkey'}, 'text' => 'Oo oo aa aa'}}
+            @ss_message = {'for_user' => '321', 'message' => {'id' => 123, 'user' => {'screen_name' => 'monkey'}, 'text' => 'Oo oo aa aa'}}
           end
 
-          it "yields a site stream message" do
+          it 'yields a site stream message' do
             expect(@stream).to receive(:each).and_yield(@ss_message.to_json)
             yielded_status = nil
             @client.sitestream do |message|
               yielded_status = message
             end
             expect(yielded_status).not_to be_nil
-            expect(yielded_status[:for_user]).to eq('12345')
+            expect(yielded_status[:for_user]).to eq('321')
             expect(yielded_status[:message][:user][:screen_name]).to eq('monkey')
             expect(yielded_status[:message][:text]).to eq('Oo oo aa aa')
           end
-          it "yields itself if block has an arity of 2" do
+          it 'yields itself if block has an arity of 2' do
             expect(@stream).to receive(:each).and_yield(@ss_message.to_json)
             yielded_client = nil
             @client.sitestream do |_, client|
@@ -136,12 +136,12 @@ describe TweetStream::Client do
           end
         end
 
-        context "friends list" do
+        context 'friends list' do
           before do
-            @friends_list = { 'friends' => [123, 456] }
-         end
+            @friends_list = {'friends' => [123, 456]}
+          end
 
-          it "yields a friends list array" do
+          it 'yields a friends list array' do
             expect(@stream).to receive(:each).and_yield(@friends_list.to_json)
             yielded_list = nil
             @client.on_friends do |friends|

data/spec/tweetstream/client_spec.rb

@@ -11,74 +11,74 @@ describe TweetStream::Client do
     @client = TweetStream::Client.new
   end
 
-  describe "#start" do
+  describe '#start' do
     before do
-      @stream = double("EM::Twitter::Client",
-        :connect => true,
-        :unbind => true,
-        :each => true,
-        :on_error => true,
-        :on_max_reconnects => true,
-        :on_reconnect => true,
-        :connection_completed => true,
-        :on_no_data_received => true,
-        :on_unauthorized => true,
-        :on_enhance_your_calm => true
+      @stream = double('EM::Twitter::Client',
+                       :connect => true,
+                       :unbind => true,
+                       :each => true,
+                       :on_error => true,
+                       :on_max_reconnects => true,
+                       :on_reconnect => true,
+                       :connection_completed => true,
+                       :on_no_data_received => true,
+                       :on_unauthorized => true,
+                       :on_enhance_your_calm => true
       )
       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
+    it 'connects if the reactor is already running' do
       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
+    it 'starts the reactor if not already running' do
       expect(EM).to receive(:run).once
       @client.track('abc')
     end
 
-    it "warns when callbacks are passed as options" do
+    it 'warns when callbacks are passed as options' do
       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 { })
+      @client.track('abc', :inited => proc {})
     end
 
     describe 'proxy usage' do
       it 'connects with a proxy' do
-        @client = TweetStream::Client.new(:proxy => { :uri => 'http://someproxy:8081'})
+        @client = TweetStream::Client.new(:proxy => {:uri => 'http://someproxy:8081'})
         expect(EM::Twitter::Client).to receive(:connect).
-          with(hash_including(:proxy => { :uri => 'http://someproxy:8081'})).and_return(@stream)
+          with(hash_including(:proxy => {:uri => 'http://someproxy:8081'})).and_return(@stream)
         expect(@stream).to receive(:each).and_return
         @client.track('abc')
       end
     end
 
-    describe "#each" do
-      it "calls the appropriate parser" do
+    describe '#each' do
+      it 'calls the appropriate parser' do
         @client = TweetStream::Client.new
         expect(MultiJson).to receive(:decode).and_return({})
         expect(@stream).to receive(:each).and_yield(sample_tweets[0].to_json)
-        @client.track('abc','def')
+        @client.track('abc', 'def')
       end
 
-      it "yields a Twitter::Tweet" do
+      it 'yields a Twitter::Tweet' do
         expect(@stream).to receive(:each).and_yield(sample_tweets[0].to_json)
-        @client.track('abc'){|s| expect(s).to be_kind_of(Twitter::Tweet)}
+        @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
+      it 'yields the client if a block with arity 2 is given' do
         expect(@stream).to receive(:each).and_yield(sample_tweets[0].to_json)
-        @client.track('abc'){|s,c| expect(c).to eq(@client)}
+        @client.track('abc') { |s, c| expect(c).to eq(@client) }
       end
 
-      it "includes the proper values" do
+      it 'includes the proper values' do
         tweet = sample_tweets[0]
         tweet[:id] = 123
         tweet[:user][:screen_name] = 'monkey'
-        tweet[:text] = "Oo oo aa aa"
+        tweet[:text] = 'Oo oo aa aa'
         expect(@stream).to receive(:each).and_yield(tweet.to_json)
         @client.track('abc') do |s|
           expect(s[:id]).to eq(123)
@@ -87,62 +87,62 @@ describe TweetStream::Client do
         end
       end
 
-      it "calls the on_stall_warning callback if specified" do
+      it 'calls the on_stall_warning callback if specified' do
         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
+      it 'calls the on_scrub_geo callback if specified' do
         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)
+          expect(up_to_status_id).to eq(987)
+          expect(user_id).to eq(123)
         end.track('abc')
       end
 
-      it "calls the on_delete callback" do
+      it 'calls the on_delete callback' do
         expect(@stream).to receive(:each).and_yield(fixture('delete.json'))
         @client.on_delete do |id, user_id|
-          expect(id).to eq(1234)
+          expect(id).to eq(123)
           expect(user_id).to eq(3)
         end.track('abc')
       end
 
-      it "calls the on_limit callback" do
+      it 'calls the on_limit callback' do
         limit = nil
         expect(@stream).to receive(:each).and_yield(fixture('limit.json'))
         @client.on_limit do |l|
           limit = l
         end.track('abc')
 
-        expect(limit).to eq(1234)
+        expect(limit).to eq(123)
       end
 
-      it "calls the on_status_withheld callback" do
+      it 'calls the on_status_withheld callback' do
         status = nil
         expect(@stream).to receive(:each).and_yield(fixture('status_withheld.json'))
         @client.on_status_withheld do |s|
           status = s
         end.track('abc')
 
-        expect(status[:user_id]).to eq(123456)
+        expect(status[:user_id]).to eq(123)
       end
 
-      it "calls the on_user_withheld callback" do
+      it 'calls the on_user_withheld callback' do
         status = nil
         expect(@stream).to receive(:each).and_yield(fixture('user_withheld.json'))
         @client.on_user_withheld do |s|
           status = s
         end.track('abc')
 
-        expect(status[:id]).to eq(123456)
+        expect(status[:id]).to eq(123)
       end
 
-      context "using on_anything" do
-        it "yields the raw hash" do
-          hash = {:id => 1234}
+      context 'using on_anything' do
+        it 'yields the raw hash' do
+          hash = {:id => 123}
           expect(@stream).to receive(:each).and_yield(hash.to_json)
           yielded_hash = nil
           @client.on_anything do |h|
@@ -150,10 +150,10 @@ describe TweetStream::Client do
           end.track('abc')
 
           expect(yielded_hash).not_to be_nil
-          expect(yielded_hash[:id]).to eq(1234)
+          expect(yielded_hash[:id]).to eq(123)
         end
-        it "yields itself if block has an arity of 2" do
-          hash = {:id => 1234}
+        it 'yields itself if block has an arity of 2' do
+          hash = {:id => 123}
           expect(@stream).to receive(:each).and_yield(hash.to_json)
           yielded_client = nil
           @client.on_anything do |_, client|
@@ -164,12 +164,12 @@ describe TweetStream::Client do
         end
       end
 
-      context "using on_timeline_status" do
-        it "yields a Status" do
+      context 'using on_timeline_status' do
+        it 'yields a Status' do
           tweet = sample_tweets[0]
           tweet[:id] = 123
           tweet[:user][:screen_name] = 'monkey'
-          tweet[:text] = "Oo oo aa aa"
+          tweet[:text] = 'Oo oo aa aa'
           expect(@stream).to receive(:each).and_yield(tweet.to_json)
           yielded_status = nil
           @client.on_timeline_status do |status|
@@ -180,7 +180,7 @@ describe TweetStream::Client do
           expect(yielded_status.user.screen_name).to eq('monkey')
           expect(yielded_status.text).to eq('Oo oo aa aa')
         end
-        it "yields itself if block has an arity of 2" do
+        it 'yields itself if block has an arity of 2' do
           expect(@stream).to receive(:each).and_yield(sample_tweets[0].to_json)
           yielded_client = nil
           @client.on_timeline_status do |_, client|
@@ -191,22 +191,22 @@ describe TweetStream::Client do
         end
       end
 
-      context "using on_direct_message" do
-        it "yields a DirectMessage" do
+      context 'using on_direct_message' do
+        it 'yields a DirectMessage' do
           direct_message = sample_direct_messages[0]
-          direct_message[:direct_message][:id] = 1234
-          direct_message[:direct_message][:sender][:screen_name] = "coder"
+          direct_message[:direct_message][:id] = 123
+          direct_message[:direct_message][:sender][:screen_name] = 'coder'
           expect(@stream).to receive(:each).and_yield(direct_message.to_json)
           yielded_dm = nil
           @client.on_direct_message do |dm|
             yielded_dm = dm
           end.userstream
           expect(yielded_dm).not_to be_nil
-          expect(yielded_dm.id).to eq(1234)
-          expect(yielded_dm.sender.screen_name).to eq("coder")
+          expect(yielded_dm.id).to eq(123)
+          expect(yielded_dm.sender.screen_name).to eq('coder')
         end
 
-        it "yields itself if block has an arity of 2" do
+        it 'yields itself if block has an arity of 2' do
           expect(@stream).to receive(:each).and_yield(sample_direct_messages[0].to_json)
           yielded_client = nil
           @client.on_direct_message do |_, client|
@@ -216,14 +216,14 @@ describe TweetStream::Client do
         end
       end
 
-      it "calls on_error if a non-hash response is received" do
+      it 'calls on_error if a non-hash response is received' do
         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
+      it 'calls on_error if a json parse error occurs' do
         expect(@stream).to receive(:each).and_yield("{'a_key':}")
         @client.on_error do |message|
           expect(message).to eq("MultiJson::DecodeError occured in stream: {'a_key':}")
@@ -231,33 +231,33 @@ describe TweetStream::Client do
       end
     end
 
-    describe "#on_error" do
-      it "passes the message on to the error block" do
+    describe '#on_error' do
+      it 'passes the message on to the error block' do
         expect(@stream).to receive(:on_error).and_yield('Uh oh')
         @client.on_error do |m|
           expect(m).to eq('Uh oh')
         end.track('abc')
       end
 
-      it "returns the block when defined" do
+      it 'returns the block when defined' do
         @client.on_error { |m| true; }
         expect(@client.on_error).to be_kind_of(Proc)
       end
 
-      it "returns nil when undefined" do
+      it 'returns nil when undefined' do
         expect(@client.on_error).to be_nil
       end
     end
 
-    describe "#on_max_reconnects" do
-      it "raises a ReconnectError" do
+    describe '#on_max_reconnects' do
+      it 'raises a ReconnectError' do
         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.")
+        expect(lambda { @client.track('abc') }).to raise_error(TweetStream::ReconnectError, 'Failed to reconnect after 20 tries.')
       end
     end
   end
 
-  describe "API methods" 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
         expect(@client).to receive(:start).once.with('/1.1/statuses/' + method + '.json', {})
@@ -265,7 +265,7 @@ describe TweetStream::Client do
       end
     end
 
-    describe "#filter" do
+    describe '#filter' do
       it "makes a call to 'statuses/filter' with the query params provided" do
         expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :follow => 123, :method => :post)
         @client.filter(:follow => 123)
@@ -276,19 +276,19 @@ describe TweetStream::Client do
       end
     end
 
-    describe "#follow" do
+    describe '#follow' do
       it "makes a call to start with 'statuses/filter' and a follow query parameter" do
         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
-        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :follow => [123,456], :method => :post)
+      it 'comma-joins multiple arguments' do
+        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
+    describe '#locations' do
       it "calls #start with 'statuses/filter' with the query params provided longitude/latitude pairs" do
         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')
@@ -300,24 +300,24 @@ describe TweetStream::Client do
       end
     end
 
-    describe "#track" do
+    describe '#track' do
       it "makes a call to start with 'statuses/filter' and a track query parameter" do
-        expect(@client).to 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 => %w[test], :method => :post)
         @client.track('test')
       end
 
-      it "comma-joins multiple arguments" do
-        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :track => ['foo', 'bar', 'baz'], :method => :post)
+      it 'comma-joins multiple arguments' do
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :track => %w[foo bar baz], :method => :post)
         @client.track('foo', 'bar', 'baz')
       end
 
-      it "comma-joins an array of arguments" do
-        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :track => [['foo','bar','baz']], :method => :post)
-        @client.track(['foo','bar','baz'])
+      it 'comma-joins an array of arguments' do
+        expect(@client).to receive(:start).once.with('/1.1/statuses/filter.json', :track => [%w[foo bar baz]], :method => :post)
+        @client.track(%w[foo bar baz])
       end
 
       it "calls #start with 'statuses/filter' and the provided queries" do
-        expect(@client).to 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 => %w[rock], :method => :post)
         @client.track('rock')
       end
     end
@@ -325,25 +325,25 @@ describe TweetStream::Client do
 
   %w(on_delete on_limit on_inited on_reconnect on_no_data_received on_unauthorized on_enhance_your_calm).each do |proc_setter|
     describe "##{proc_setter}" do
-      it "sets when a block is given" do
-        proc = Proc.new{|a,b| puts a }
-        @client.send(proc_setter, &proc)
-        expect(@client.send(proc_setter)).to eq(proc)
+      it 'sets when a block is given' do
+        block = proc { |a, b| puts a }
+        @client.send(proc_setter, &block)
+        expect(@client.send(proc_setter)).to eq(block)
       end
 
-      it "returns nil when undefined" do
+      it 'returns nil when undefined' do
         expect(@client.send(proc_setter)).to be_nil
       end
     end
   end
 
-  describe "#stop" do
-    it "calls EventMachine::stop_event_loop" do
+  describe '#stop' do
+    it 'calls EventMachine::stop_event_loop' do
       expect(EventMachine).to receive(:stop_event_loop)
       expect(TweetStream::Client.new.stop).to be_nil
     end
 
-    it "returns the last status yielded" do
+    it 'returns the last status yielded' do
       expect(EventMachine).to receive(:stop_event_loop)
       client = TweetStream::Client.new
       client.send(:instance_variable_set, :@last_status, {})
@@ -351,39 +351,39 @@ describe TweetStream::Client do
     end
   end
 
-  describe "#close_connection" do
-    it "does not call EventMachine::stop_event_loop" do
+  describe '#close_connection' do
+    it 'does not call EventMachine::stop_event_loop' do
       expect(EventMachine).not_to receive(:stop_event_loop)
       expect(TweetStream::Client.new.close_connection).to be_nil
     end
   end
 
-  describe "#stop_stream" do
+  describe '#stop_stream' do
     before(:each) do
-      @stream = double("EM::Twitter::Client",
-        :connect => true,
-        :unbind => true,
-        :each => true,
-        :on_error => true,
-        :on_max_reconnects => true,
-        :on_reconnect => true,
-        :connection_completed => true,
-        :on_no_data_received => true,
-        :on_unauthorized => true,
-        :on_enhance_your_calm => true,
-        :stop => true
+      @stream = double('EM::Twitter::Client',
+                       :connect => true,
+                       :unbind => true,
+                       :each => true,
+                       :on_error => true,
+                       :on_max_reconnects => true,
+                       :on_reconnect => true,
+                       :connection_completed => true,
+                       :on_no_data_received => true,
+                       :on_unauthorized => true,
+                       :on_enhance_your_calm => true,
+                       :stop => true
       )
       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
+    it 'calls stream.stop to cleanly stop the current stream' do
       expect(@stream).to receive(:stop)
       @client.stop_stream
     end
 
-    it "does not stop eventmachine" do
+    it 'does not stop eventmachine' do
       expect(EventMachine).not_to receive(:stop_event_loop)
       @client.stop_stream
     end