tweetstream 2.3.0 → 2.4.0

data/spec/tweetstream/client_spec.rb

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 describe TweetStream::Client do
   before(:each) do
     TweetStream.configure do |config|
@@ -9,7 +11,7 @@ describe TweetStream::Client do
     @client = TweetStream::Client.new
   end
 
-  describe '#start' do
+  describe "#start" do
     before do
       @stream = stub("EM::Twitter::Client",
         :connect => true,
@@ -27,105 +29,105 @@ describe TweetStream::Client do
       EM::Twitter::Client.stub!(:connect).and_return(@stream)
     end
 
-    it 'connects if the reactor is already running' do
+    it "connects if the reactor is already running" do
       EM.stub!(:reactor_running?).and_return(true)
       @client.should_receive(:connect)
       @client.track('abc')
     end
 
-    it 'starts the reactor if not already running' do
+    it "starts the reactor if not already running" do
       EM.should_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
       @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/)
       @client.track('abc', :inited => Proc.new { })
     end
 
-    describe '#each' do
-      it 'calls the appropriate parser' do
+    describe "#each" do
+      it "calls the appropriate parser" do
         @client = TweetStream::Client.new
-        MultiJson.should_receive(:decode).and_return({})
+        Yajl::Parser.should_receive(:parse).twice.and_return({})
         @stream.should_receive(:each).and_yield(sample_tweets[0].to_json)
         @client.track('abc','def')
       end
 
-      it 'yields a Twitter::Tweet' do
+      it "yields a Twitter::Tweet" do
         @stream.should_receive(:each).and_yield(sample_tweets[0].to_json)
-        @client.track('abc'){|s| s.should 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
         @stream.should_receive(:each).and_yield(sample_tweets[0].to_json)
-        @client.track('abc'){|s,c| c.should == @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"
         @stream.should_receive(:each).and_yield(tweet.to_json)
         @client.track('abc') do |s|
-          s[:id].should == 123
-          s.user.screen_name.should == 'monkey'
-          s.text.should == 'Oo oo aa aa'
+          expect(s[:id]).to eq(123)
+          expect(s.user.screen_name).to eq('monkey')
+          expect(s.text).to eq('Oo oo aa aa')
         end
       end
 
-      it 'calls the on_stall_warning callback if specified' do
+      it "calls the on_stall_warning callback if specified" do
         @stream.should_receive(:each).and_yield(fixture('stall_warning.json'))
         @client.on_stall_warning do |warning|
-          warning[:code].should eq('FALLING_BEHIND')
+          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
         @stream.should_receive(:each).and_yield(fixture('scrub_geo.json'))
         @client.on_scrub_geo do |up_to_status_id, user_id|
-          up_to_status_id.should == 9876
-          user_id.should == 1234
+          expect(up_to_status_id).to eq(9876)
+          expect(user_id).to eq(1234)
         end.track('abc')
       end
 
-      it 'calls the on_delete callback' do
+      it "calls the on_delete callback" do
         @stream.should_receive(:each).and_yield(fixture('delete.json'))
         @client.on_delete do |id, user_id|
-          id.should == 1234
-          user_id.should == 3
+          expect(id).to eq(1234)
+          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
         @stream.should_receive(:each).and_yield(fixture('limit.json'))
         @client.on_limit do |l|
           limit = l
         end.track('abc')
 
-        limit.should eq(1234)
+        expect(limit).to eq(1234)
       end
 
-      it 'calls the on_status_withheld callback' do
+      it "calls the on_status_withheld callback" do
         status = nil
         @stream.should_receive(:each).and_yield(fixture('status_withheld.json'))
         @client.on_status_withheld do |s|
           status = s
         end.track('abc')
 
-        status[:user_id].should eq(123456)
+        expect(status[:user_id]).to eq(123456)
       end
 
-      it 'calls the on_user_withheld callback' do
+      it "calls the on_user_withheld callback" do
         status = nil
         @stream.should_receive(:each).and_yield(fixture('user_withheld.json'))
         @client.on_user_withheld do |s|
           status = s
         end.track('abc')
 
-        status[:id].should eq(123456)
+        expect(status[:id]).to eq(123456)
       end
 
       context "using on_anything" do
@@ -137,23 +139,23 @@ describe TweetStream::Client do
             yielded_hash = h
           end.track('abc')
 
-          yielded_hash.should_not be_nil
-          yielded_hash[:id].should eq(1234)
+          expect(yielded_hash).not_to be_nil
+          expect(yielded_hash[:id]).to eq(1234)
         end
-        it 'yields itself if block has an arity of 2' do
+        it "yields itself if block has an arity of 2" do
           hash = {:id => 1234}
           @stream.should_receive(:each).and_yield(hash.to_json)
           yielded_client = nil
           @client.on_anything do |_, client|
             yielded_client = client
           end.track('abc')
-          yielded_client.should_not be_nil
-          yielded_client.should == @client
+          expect(yielded_client).not_to be_nil
+          expect(yielded_client).to eq(@client)
         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'
@@ -163,24 +165,24 @@ describe TweetStream::Client do
           @client.on_timeline_status do |status|
             yielded_status = status
           end.track('abc')
-          yielded_status.should_not be_nil
-          yielded_status[:id].should == 123
-          yielded_status.user.screen_name.should == 'monkey'
-          yielded_status.text.should == 'Oo oo aa aa'
+          expect(yielded_status).not_to be_nil
+          expect(yielded_status[:id]).to eq(123)
+          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
           @stream.should_receive(:each).and_yield(sample_tweets[0].to_json)
           yielded_client = nil
           @client.on_timeline_status do |_, client|
             yielded_client = client
           end.track('abc')
-          yielded_client.should_not be_nil
-          yielded_client.should == @client
+          expect(yielded_client).not_to be_nil
+          expect(yielded_client).to eq(@client)
         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"
@@ -189,63 +191,63 @@ describe TweetStream::Client do
           @client.on_direct_message do |dm|
             yielded_dm = dm
           end.userstream
-          yielded_dm.should_not be_nil
-          yielded_dm.id.should == 1234
-          yielded_dm.sender.screen_name.should == "coder"
+          expect(yielded_dm).not_to be_nil
+          expect(yielded_dm.id).to eq(1234)
+          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
           @stream.should_receive(:each).and_yield(sample_direct_messages[0].to_json)
           yielded_client = nil
           @client.on_direct_message do |_, client|
             yielded_client = client
           end.userstream
-          yielded_client.should == @client
+          expect(yielded_client).to eq(@client)
         end
       end
 
-      it 'should call on_error if a non-hash response is received' do
+      it "calls on_error if a non-hash response is received" do
         @stream.should_receive(:each).and_yield('["favorited"]')
         @client.on_error do |message|
-          message.should == 'Unexpected JSON object in stream: ["favorited"]'
+          expect(message).to eq('Unexpected JSON object in stream: ["favorited"]')
         end.track('abc')
       end
 
-      it 'should call on_error if a json parse error occurs' do
+      it "calls on_error if a json parse error occurs" do
         @stream.should_receive(:each).and_yield("{'a_key':}")
         @client.on_error do |message|
-          message.should == "MultiJson::DecodeError occured in stream: {'a_key':}"
+          expect(message).to eq("Yajl::ParseError occured in stream: {'a_key':}")
         end.track('abc')
       end
     end
 
-    describe '#on_error' do
-      it 'should pass the message on to the error block' do
+    describe "#on_error" do
+      it "passes the message on to the error block" do
         @stream.should_receive(:on_error).and_yield('Uh oh')
         @client.on_error do |m|
-          m.should == 'Uh oh'
+          expect(m).to eq('Uh oh')
         end.track('abc')
       end
 
-      it 'should return the block when defined' do
+      it "returns the block when defined" do
         @client.on_error { |m| true; }
-        @client.on_error.should be_kind_of(Proc)
+        expect(@client.on_error).to be_kind_of(Proc)
       end
 
-      it 'should return nil when undefined' do
-        @client.on_error.should be_nil
+      it "returns nil when undefined" do
+        expect(@client.on_error).to be_nil
       end
     end
 
-    describe '#on_max_reconnects' do
-      it 'should raise a ReconnectError' do
+    describe "#on_max_reconnects" do
+      it "raises a ReconnectError" do
         @stream.should_receive(:on_max_reconnects).and_yield(30, 20)
-        lambda{ @client.track('abc') }.should 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
         @client.should_receive(:start).once.with('/1.1/statuses/' + method + '.json', {})
@@ -253,58 +255,58 @@ describe TweetStream::Client do
       end
     end
 
-    describe '#filter' do
-      it 'makes a call to "statuses/filter" with the query params provided' do
+    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)
         @client.filter(:follow => 123)
       end
-      it 'makes a call to "statuses/filter" with the query params provided longitude/latitude pairs, separated by commas ' do
+      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)
         @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
+    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)
         @client.follow(123)
       end
 
-      it 'comma-joins multiple arguments' do
+      it "comma-joins multiple arguments" do
         @client.should_receive(:start).once.with('/1.1/statuses/filter.json', :follow => [123,456], :method => :post)
         @client.follow(123, 456)
       end
     end
 
-    describe '#locations' do
-      it 'should call #start with "statuses/filter" with the query params provided longitude/latitude pairs' do
+    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)
         @client.locations('-122.75,36.8,-121.75,37.8,-74,40,-73,41')
       end
 
-      it 'should call #start with "statuses/filter" with the query params provided longitude/latitude pairs and additional filter' do
+      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)
         @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
+    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)
         @client.track('test')
       end
 
-      it 'comma-joins multiple arguments' do
+      it "comma-joins multiple arguments" do
         @client.should_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
+      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)
         @client.track(['foo','bar','baz'])
       end
 
-      it 'should call #start with "statuses/filter" and the provided queries' do
+      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)
         @client.track('rock')
       end
@@ -313,40 +315,40 @@ 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 'should set when a block is given' do
+      it "sets when a block is given" do
         proc = Proc.new{|a,b| puts a }
         @client.send(proc_setter, &proc)
-        @client.send(proc_setter).should == proc
+        expect(@client.send(proc_setter)).to eq(proc)
       end
 
-      it 'should return nil when undefined' do
-        @client.send(proc_setter).should be_nil
+      it "returns nil when undefined" do
+        expect(@client.send(proc_setter)).to be_nil
       end
     end
   end
 
-  describe '#stop' do
-    it 'should call EventMachine::stop_event_loop' do
+  describe "#stop" do
+    it "calls EventMachine::stop_event_loop" do
       EventMachine.should_receive :stop_event_loop
-      TweetStream::Client.new.stop.should be_nil
+      expect(TweetStream::Client.new.stop).to be_nil
     end
 
-    it 'should return the last status yielded' do
+    it "returns the last status yielded" do
       EventMachine.should_receive :stop_event_loop
       client = TweetStream::Client.new
       client.send(:instance_variable_set, :@last_status, {})
-      client.stop.should == {}
+      expect(client.stop).to eq({})
     end
   end
 
-  describe '#close_connection' do
-    it 'should not call EventMachine::stop_event_loop' do
+  describe "#close_connection" do
+    it "does not call EventMachine::stop_event_loop" do
       EventMachine.should_not_receive :stop_event_loop
-      TweetStream::Client.new.close_connection.should be_nil
+      expect(TweetStream::Client.new.close_connection).to be_nil
     end
   end
 
-  describe '#stop_stream' do
+  describe "#stop_stream" do
     before(:each) do
       @stream = stub("EM::Twitter::Client",
         :connect => true,
@@ -366,12 +368,12 @@ describe TweetStream::Client do
       @client.connect('/')
     end
 
-    it "should call stream.stop to cleanly stop the current stream" do
+    it "calls stream.stop to cleanly stop the current stream" do
       @stream.should_receive(:stop)
       @client.stop_stream
     end
 
-    it 'should not stop eventmachine' do
+    it "does not stop eventmachine" do
       EventMachine.should_not_receive :stop_event_loop
       @client.stop_stream
     end

data/spec/tweetstream/client_userstream_spec.rb

@@ -27,7 +27,7 @@ describe TweetStream::Client do
   end
 
   describe "User Stream support" do
-    context 'when calling #userstream' do
+    context "when calling #userstream" do
       it "sends the userstream host" do
         EM::Twitter::Client.should_receive(:connect).with(hash_including(:host => "userstream.twitter.com")).and_return(@stream)
         @client.userstream
@@ -38,35 +38,35 @@ describe TweetStream::Client do
         @client.userstream
       end
 
-      it 'supports "replies"' do
+      it "supports :replies => 'all'" do
         @client.should_receive(:start).once.with("/1.1/user.json", hash_including(:replies => 'all')).and_return(@stream)
         @client.userstream(:replies => 'all')
       end
 
-      it 'supports "stall_warnings"' do
+      it "supports :stall_warnings => 'true'" do
         @client.should_receive(:start).once.with("/1.1/user.json", hash_including(:stall_warnings => 'true')).and_return(@stream)
         @client.userstream(:stall_warnings => 'true')
       end
 
-      it 'supports "with followings"' do
+      it "supports :with => 'followings'" do
         @client.should_receive(:start).once.with("/1.1/user.json", hash_including(:with => 'followings')).and_return(@stream)
         @client.userstream(:with => 'followings')
       end
 
-      it 'supports "with user"' do
+      it "supports :with => 'user'" do
         @client.should_receive(:start).once.with("/1.1/user.json", hash_including(:with => 'user')).and_return(@stream)
         @client.userstream(:with => 'user')
       end
 
-      it 'supports event callbacks' do
+      it "supports event callbacks" do
         event = nil
         @stream.should_receive(:each).and_yield(fixture('favorite.json'))
         @client.on_event(:favorite) do |e|
           event = e
         end.userstream
 
-        event[:source].should_not be_nil
-        event[:target].should_not be_nil
+        expect(event[:source]).not_to be_nil
+        expect(event[:target]).not_to be_nil
       end
     end
   end