em-twitter 0.2.1 → 0.2.2

data/spec/em-twitter/decoders/base_decoder_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 describe EM::Twitter::BaseDecoder do
 
-  describe '#decode' do
+  describe "#decode" do
     before do
       @decoder = EM::Twitter::BaseDecoder.new
     end
 
-    it 'passes through the response data' do
-      @decoder.decode('abc').should eq('abc')
+    it "passes through the response data" do
+      expect(@decoder.decode('abc')).to eq('abc')
     end
   end
 
-end
+end

data/spec/em-twitter/decoders/gzip_decoder_spec.rb

@@ -2,19 +2,19 @@ require 'spec_helper'
 
 describe EM::Twitter::GzipDecoder do
 
-  describe '#decode' do
+  describe "#decode" do
     before do
       @decoder = EM::Twitter::GzipDecoder.new
     end
 
-    it 'decodes the response data' do
+    it "decodes the response data" do
       output = StringIO.new
       gz = Zlib::GzipWriter.new(output)
       gz.write('abc')
       gz.close
 
-      @decoder.decode(output.string).should eq('abc')
+      expect(@decoder.decode(output.string)).to eq('abc')
     end
   end
 
-end
+end

data/spec/em-twitter/proxy_spec.rb

@@ -1,23 +1,23 @@
 require 'spec_helper'
 
 describe EM::Twitter::Proxy do
-  describe '.new' do
-    it 'interprets a proxy configuration' do
+  describe ".new" do
+    it "interprets a proxy configuration" do
       proxy = EM::Twitter::Proxy.new(proxy_options[:proxy])
-      proxy.user.should eq('username')
-      proxy.password.should eq('password')
-      proxy.uri.should eq('http://my-proxy:8080')
+      expect(proxy.user).to eq('username')
+      expect(proxy.password).to eq('password')
+      expect(proxy.uri).to eq('http://my-proxy:8080')
     end
   end
 
-  describe '#header' do
-    it 'returns false when no proxy credentials are passed' do
-      EM::Twitter::Proxy.new.header.should be_false
+  describe "#header" do
+    it "returns false when no proxy credentials are passed" do
+      expect(EM::Twitter::Proxy.new.header).to be_false
     end
 
-    it 'generates a header when passed credentials' do
+    it "generates a header when passed credentials" do
       proxy = EM::Twitter::Proxy.new(proxy_options[:proxy])
-      proxy.header.should be
+      expect(proxy.header).to be
     end
   end
-end
+end

data/spec/em-twitter/reconnectors/application_failure_spec.rb

@@ -3,40 +3,40 @@ require 'spec_helper'
 include EM::Twitter::Reconnectors
 
 describe EM::Twitter::Reconnectors::ApplicationFailure do
-  describe 'initialization' do
-    it 'initializes the reconnect_timeout' do
+  describe "initialization" do
+    it "initializes the reconnect_timeout" do
       reconn = ApplicationFailure.new
-      reconn.reconnect_timeout.should eq(ApplicationFailure::START)
+      expect(reconn.reconnect_timeout).to eq(ApplicationFailure::START)
     end
 
-    it 'accepts an options hash' do
+    it "accepts an options hash" do
       reconn = ApplicationFailure.new(:reconnect_count => 25)
-      reconn.reconnect_count.should eq(25)
+      expect(reconn.reconnect_count).to eq(25)
     end
   end
 
-  describe 'reconnect_timeout' do
-    it 'returns the reconnect_timeout' do
+  describe "reconnect_timeout" do
+    it "returns the reconnect_timeout" do
       reconn = ApplicationFailure.new
       reconn.reconnect_timeout = 12
-      reconn.reconnect_timeout.should eq(12)
+      expect(reconn.reconnect_timeout).to eq(12)
     end
   end
 
-  describe '#increment' do
-    it 'increments the reconnect_count' do
+  describe "#increment" do
+    it "increments the reconnect_count" do
       reconn = ApplicationFailure.new
       reconn.increment
-      reconn.reconnect_count.should eq(1)
+      expect(reconn.reconnect_count).to eq(1)
     end
 
-    it 'increments the reconnect_timeout' do
+    it "increments the reconnect_timeout" do
       reconn = ApplicationFailure.new
       reconn.increment
-      reconn.reconnect_timeout.should eq(20)
+      expect(reconn.reconnect_timeout).to eq(20)
     end
 
-    it 'accepts a block and yields the current timeout' do
+    it "accepts a block and yields the current timeout" do
       recon_timeout = 0
 
       reconn = ApplicationFailure.new
@@ -44,31 +44,31 @@ describe EM::Twitter::Reconnectors::ApplicationFailure do
         recon_timeout = timeout
       end
 
-      recon_timeout.should eq(10)
+      expect(recon_timeout).to eq(10)
     end
 
-    it 'raises an ReconnectLimitError after exceeding max reconnects' do
-      lambda {
+    it "raises an ReconnectLimitError after exceeding max reconnects" do
+      expect {
         reconn = ApplicationFailure.new(:reconnect_count => 11)
         reconn.increment
-      }.should raise_error(EventMachine::Twitter::ReconnectLimitError)
+      }.to raise_error(EventMachine::Twitter::ReconnectLimitError)
     end
 
-    it 'raises an ReconnectLimitError after exceeding the reconnect time limit' do
-      lambda {
+    it "raises an ReconnectLimitError after exceeding the reconnect time limit" do
+      expect {
         reconn = ApplicationFailure.new(:reconnect_timeout => 321)
         reconn.increment
-      }.should raise_error(EventMachine::Twitter::ReconnectLimitError)
+      }.to raise_error(EventMachine::Twitter::ReconnectLimitError)
     end
   end
 
-  describe '#reset' do
-    it 'resets the reconnect_count' do
+  describe "#reset" do
+    it "resets the reconnect_count" do
       reconn = ApplicationFailure.new(:reconnect_count => 25)
-      reconn.reconnect_count.should eq(25)
+      expect(reconn.reconnect_count).to eq(25)
 
       reconn.reset
-      reconn.reconnect_count.should be_zero
+      expect(reconn.reconnect_count).to be_zero
     end
   end
-end
+end

data/spec/em-twitter/reconnectors/network_failure_spec.rb

@@ -3,46 +3,46 @@ require 'spec_helper'
 include EM::Twitter::Reconnectors
 
 describe EM::Twitter::Reconnectors::NetworkFailure do
-  describe 'initialization' do
-    it 'initializes the reconnect_timeout' do
+  describe "initialization" do
+    it "initializes the reconnect_timeout" do
       reconn = NetworkFailure.new
-      reconn.reconnect_timeout.should eq(NetworkFailure::START)
+      expect(reconn.reconnect_timeout).to eq(NetworkFailure::START)
     end
 
-    it 'accepts an options hash' do
+    it "accepts an options hash" do
       reconn = NetworkFailure.new(:reconnect_count => 25)
-      reconn.reconnect_count.should eq(25)
+      expect(reconn.reconnect_count).to eq(25)
     end
   end
 
-  describe 'reconnect_timeout' do
-    it 'returns the reconnect_timeout' do
+  describe "reconnect_timeout" do
+    it "returns the reconnect_timeout" do
       reconn = NetworkFailure.new
       reconn.reconnect_timeout = 12
-      reconn.reconnect_timeout.should eq(12)
+      expect(reconn.reconnect_timeout).to eq(12)
     end
 
-    it 'returns the maximum timeout when greater than the max' do
+    it "returns the maximum timeout when greater than the max" do
       reconn = NetworkFailure.new
       reconn.reconnect_timeout = NetworkFailure::MAX_TIMEOUT + 2
-      reconn.reconnect_timeout.should eq(NetworkFailure::MAX_TIMEOUT)
+      expect(reconn.reconnect_timeout).to eq(NetworkFailure::MAX_TIMEOUT)
     end
   end
 
-  describe '#increment' do
-    it 'increments the reconnect_count' do
+  describe "#increment" do
+    it "increments the reconnect_count" do
       reconn = NetworkFailure.new
       reconn.increment
-      reconn.reconnect_count.should eq(1)
+      expect(reconn.reconnect_count).to eq(1)
     end
 
-    it 'increments the reconnect_timeout' do
+    it "increments the reconnect_timeout" do
       reconn = NetworkFailure.new
       reconn.increment
-      reconn.reconnect_timeout.should eq(0.5)
+      expect(reconn.reconnect_timeout).to eq(0.5)
     end
 
-    it 'accepts a block and yields the current timeout' do
+    it "accepts a block and yields the current timeout" do
       recon_timeout = 0
 
       reconn = NetworkFailure.new
@@ -50,31 +50,31 @@ describe EM::Twitter::Reconnectors::NetworkFailure do
         recon_timeout = timeout
       end
 
-      recon_timeout.should eq(0.25)
+      expect(recon_timeout).to eq(0.25)
     end
 
-    it 'raises an ReconnectLimitError after exceeding max reconnects' do
-      lambda {
+    it "raises an ReconnectLimitError after exceeding max reconnects" do
+      expect {
         reconn = NetworkFailure.new(:reconnect_count => 11)
         reconn.increment
-      }.should raise_error(EventMachine::Twitter::ReconnectLimitError)
+      }.to raise_error(EventMachine::Twitter::ReconnectLimitError)
     end
 
-    it 'raises an ReconnectLimitError after exceeding the reconnect time limit' do
-      lambda {
+    it "raises an ReconnectLimitError after exceeding the reconnect time limit" do
+      expect {
         reconn = NetworkFailure.new(:reconnect_timeout => 321)
         reconn.increment
-      }.should raise_error(EventMachine::Twitter::ReconnectLimitError)
+      }.to raise_error(EventMachine::Twitter::ReconnectLimitError)
     end
   end
 
-  describe '#reset' do
-    it 'resets the reconnect_count' do
+  describe "#reset" do
+    it "resets the reconnect_count" do
       reconn = NetworkFailure.new(:reconnect_count => 25)
-      reconn.reconnect_count.should eq(25)
+      expect(reconn.reconnect_count).to eq(25)
 
       reconn.reset
-      reconn.reconnect_count.should be_zero
+      expect(reconn.reconnect_count).to be_zero
     end
   end
-end
+end

data/spec/em-twitter/request_spec.rb

@@ -1,102 +1,122 @@
 require 'spec_helper'
 
 describe EM::Twitter::Request do
-  describe '.new' do
-    it 'assigns a proxy if one is set' do
+  describe ".new" do
+    it "assigns a proxy if one is set" do
       req = EM::Twitter::Request.new(proxy_options)
-      req.proxy.should be
+      expect(req.proxy).to be
     end
 
-    it 'overrides defaults' do
+    it "overrides defaults" do
       req = EM::Twitter::Request.new(default_options)
-      req.options[:path].should eq('/1/statuses/filter.json')
+      expect(req.options[:path]).to eq('/1/statuses/filter.json')
     end
   end
 
-  describe '#proxy?' do
-    it 'defaults to false' do
+  describe '#oauth_header' do
+    it 'passes params on POST requests' do
+      options = default_options.merge(:method => 'POST', :host => 'stream.twitter.com', :port => 443)
+      req = EM::Twitter::Request.new(options)
+      SimpleOAuth::Header.should_receive(:new).
+        with('POST', "http://stream.twitter.com/1/statuses/filter.json", {"track"=>"nfl"}, kind_of(Hash))
+
+      req.send(:oauth_header)
+    end
+
+    it 'passes params on the querystring for GET requests' do
+      options = default_options.merge(:method => 'GET', :host => 'stream.twitter.com', :port => 443)
+      req = EM::Twitter::Request.new(options)
+      SimpleOAuth::Header.should_receive(:new).
+        with('GET', "http://stream.twitter.com/1/statuses/filter.json?track=nfl", {}, kind_of(Hash))
+
+      req.send(:oauth_header)
+    end
+  end
+
+  describe "#proxy?" do
+    it "defaults to false" do
       req = EM::Twitter::Request.new
-      req.proxy?.should be_false
+      expect(req.proxy?).to be_false
     end
 
-    it 'returns true when a proxy is set' do
+    it "returns true when a proxy is set" do
       req = EM::Twitter::Request.new(proxy_options)
-      req.proxy?.should be_true
+      expect(req.proxy?).to be_true
     end
   end
 
-  describe '#to_s' do
-    context 'without a proxy' do
+  describe "#to_s" do
+    context "without a proxy" do
       before do
         @request = EM::Twitter::Request.new(default_options)
       end
 
-      it 'requests the defined path' do
-        @request.to_s.should include('/1/statuses/filter.json')
+      it "requests the defined path" do
+        expect(@request.to_s).to include('/1/statuses/filter.json')
       end
     end
 
-    context 'when using a proxy' do
+    context "when using a proxy" do
       before do
         @request = EM::Twitter::Request.new(default_options.merge(proxy_options))
       end
 
-      it 'requests the full uri' do
-        @request.to_s.should include("POST http://#{test_options[:host]}:#{test_options[:port]}/1/statuses/filter.json")
+      it "requests the full uri" do
+        expect(@request.to_s).to include("POST http://#{test_options[:host]}:#{test_options[:port]}/1/statuses/filter.json")
       end
 
-      it 'includes a Proxy header' do
-        @request.to_s.should include('Proxy-Authorization: Basic ')
+      it "includes a Proxy header" do
+        expect(@request.to_s).to include('Proxy-Authorization: Basic ')
       end
     end
 
-    context 'Basic Authentication' do
+    context "Basic Authentication" do
       before do
         @request = EM::Twitter::Request.new(basic_auth_options)
       end
 
-      it 'creates an authorization header' do
-        @request.to_s.should include('Authorization: Basic')
+      it "creates an authorization header" do
+        expect(@request.to_s).to include('Authorization: Basic')
       end
     end
 
-    context 'gzip encoding' do
+    context "gzip encoding" do
       before do
         @request = EM::Twitter::Request.new(default_options.merge(:encoding => 'gzip'))
       end
 
-      it 'sets a keep-alive header' do
-        @request.to_s.should include('Connection: Keep-Alive')
+      it "sets a keep-alive header" do
+        expect(@request.to_s).to include('Connection: Keep-Alive')
       end
 
-      it 'sets the accept-enconding header' do
-        @request.to_s.should include('Accept-Encoding: deflate, gzip')
+      it "sets the accept-enconding header" do
+        expect(@request.to_s).to include('Accept-Encoding: deflate, gzip')
       end
     end
 
-    it 'adds a POST body' do
+    it "adds a POST body" do
       @request = EM::Twitter::Request.new(default_options)
-      @request.to_s.should include('track=nfl')
+      expect(@request.to_s).to include('track=nfl')
     end
 
-    it 'adds query parameters' do
+    it "adds query parameters" do
       @request = EM::Twitter::Request.new(default_options.merge(:method => :get))
-      @request.to_s.should include('/1/statuses/filter.json?track=nfl')
+      expect(@request.to_s).to include('/1/statuses/filter.json?track=nfl')
     end
 
-    it 'allows defining a custom user-agent' do
+    it "allows defining a custom user-agent" do
       @request = EM::Twitter::Request.new(default_options.merge(:user_agent => 'EM::Twitter Test Suite'))
-      @request.to_s.should include('User-Agent: EM::Twitter Test Suite')
+      expect(@request.to_s).to include('User-Agent: EM::Twitter Test Suite')
     end
 
-    it 'adds an accept header' do
+    it "adds an accept header" do
       @request = EM::Twitter::Request.new(default_options)
-      @request.to_s.should include('Accept: */*')
+      expect(@request.to_s).to include('Accept: */*')
     end
 
-    it 'adds custom headers' do
+    it "adds custom headers" do
       @request = EM::Twitter::Request.new(default_options.merge(:headers => { 'foo' => 'bar'}))
-      @request.to_s.should include('foo: bar')
+      expect(@request.to_s).to include('foo: bar')
     end
   end
-end
+end

data/spec/em-twitter/response_spec.rb

@@ -2,114 +2,114 @@ require 'spec_helper'
 
 describe EM::Twitter::Response do
 
-  describe '.new' do
-    it 'initializes an empty body' do
-      EM::Twitter::Response.new.body.should eq('')
+  describe ".new" do
+    it "initializes an empty body" do
+      expect(EM::Twitter::Response.new.body).to eq('')
     end
 
-    it 'initializes with a body parameter' do
-      EM::Twitter::Response.new('ohai').body.should eq('ohai')
+    it "initializes with a body parameter" do
+      expect(EM::Twitter::Response.new('ohai').body).to eq('ohai')
     end
   end
 
-  describe '#concat' do
-    it 'sets the body when empty' do
+  describe "#concat" do
+    it "sets the body when empty" do
       response = EM::Twitter::Response.new
       response.concat('{ "status" : true }')
-      response.body.should eq('{ "status" : true }')
+      expect(response.body).to eq('{ "status" : true }')
     end
 
-    it 'appends to an existing body' do
+    it "appends to an existing body" do
       response = EM::Twitter::Response.new('{ "status" : true')
       response.concat(', "enabled" : false }')
-      response.body.should eq('{ "status" : true, "enabled" : false }')
+      expect(response.body).to eq('{ "status" : true, "enabled" : false }')
     end
 
-    it 'only appends when passed json' do
+    it "only appends when passed json" do
       str = '{ "status" : true'
       response = EM::Twitter::Response.new(str)
       response.concat('ohai')
-      response.body.should eq(str)
+      expect(response.body).to eq(str)
     end
 
-    it 'passively fails on nil' do
+    it "passively fails on nil" do
       response = EM::Twitter::Response.new
-      lambda {
+      expect {
         response.concat(nil)
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
-    it 'passively fails on empty strings' do
+    it "passively fails on empty strings" do
       response = EM::Twitter::Response.new('ohai')
       response.concat('')
-      response.body.should eq('ohai')
+      expect(response.body).to eq('ohai')
     end
 
-    it 'passively fails on blank strings' do
+    it "passively fails on blank strings" do
       response = EM::Twitter::Response.new('ohai')
       response.concat('  ')
-      response.body.should eq('ohai')
+      expect(response.body).to eq('ohai')
     end
 
-    it 'is aliased as <<' do
+    it "is aliased as <<" do
       response = EM::Twitter::Response.new
       response << '{ "status" : true }'
-      response.body.should eq('{ "status" : true }')
+      expect(response.body).to eq('{ "status" : true }')
     end
 
-    it 'updates the timestamp when data is received' do
+    it "updates the timestamp when data is received" do
       response = EM::Twitter::Response.new
       response << '{ "status" : true }'
-      response.timestamp.should be_kind_of(Time)
+      expect(response.timestamp).to be_kind_of(Time)
     end
   end
 
-  describe '#complete?' do
-    it 'returns false when an incomplete body' do
-      EM::Twitter::Response.new('{ "status" : true').complete?.should be_false
+  describe "#complete?" do
+    it "returns false when an incomplete body" do
+      expect(EM::Twitter::Response.new('{ "status" : true').complete?).to be_false
     end
 
-    it 'returns false when an complete body' do
-      EM::Twitter::Response.new('{ "status" : true }').complete?.should be_true
+    it "returns false when an complete body" do
+      expect(EM::Twitter::Response.new('{ "status" : true }').complete?).to be_true
     end
   end
 
-  describe '#older_than?' do
-    it 'returns false when the last response is younger than the number of seconds' do
+  describe "#older_than?" do
+    it "returns false when the last response is younger than the number of seconds" do
       response = EM::Twitter::Response.new
-      response.older_than?(100).should be_false
+      expect(response.older_than?(100)).to be_false
     end
 
-    it 'returns true when the last response is older than the number of seconds' do
+    it "returns true when the last response is older than the number of seconds" do
       response = EM::Twitter::Response.new
       response.concat('fakebody')
       sleep(2)
-      response.older_than?(1).should be_true
+      expect(response.older_than?(1)).to be_true
     end
 
-    it 'generates a timestamp when no initial timestamp exists' do
+    it "generates a timestamp when no initial timestamp exists" do
       response = EM::Twitter::Response.new
       response.older_than?(100)
-      response.timestamp.should be_kind_of(Time)
+      expect(response.timestamp).to be_kind_of(Time)
     end
   end
 
-  describe '#empty?' do
-    it 'returns true when an empty body' do
-      EM::Twitter::Response.new.should be_empty
+  describe "#empty?" do
+    it "returns true when an empty body" do
+      expect(EM::Twitter::Response.new).to be_empty
     end
 
-    it 'returns false when a body is present' do
-      EM::Twitter::Response.new('{ "status" : true }').should_not be_empty
+    it "returns false when a body is present" do
+      expect(EM::Twitter::Response.new('{ "status" : true }')).not_to be_empty
     end
   end
 
-  describe '#reset' do
-    it 'resets the body to an empty string' do
+  describe "#reset" do
+    it "resets the body to an empty string" do
       response = EM::Twitter::Response.new('{ "status" : true }')
-      response.body.length.should be > 0
+      expect(response.body.length).to be > 0
       response.reset
-      response.body.should eq('')
+      expect(response.body).to eq('')
     end
   end
-end
+end