pusher 0.14.5 → 0.14.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9bd67ccabffeb24e369e09b592b06a9991c4795d
-  data.tar.gz: 035e6c2def599b1ce8a6cd12897a908a011fc1fa
+  metadata.gz: 6a05ddf26ee71f3e0a3d751b2889d3d1495251db
+  data.tar.gz: c9fb9b3cde9ba84f0142338f75976a48d589fd4e
 SHA512:
-  metadata.gz: da4f65dc4b9cbd5d37020d26bde929381413b3285346f5a9979d664967fc1a1a606ee84572dd1acf8bd9fb70aa5626f996383aa20ff91949dc6120242c35e8bc
-  data.tar.gz: 63ddd45053e53489dcc2759eabf4ae76b7732cc37fb0ad72866716aba87473971702f43d036fffde82d220abf87890b83395c2e09ce07c52c67f414173fcab35
+  metadata.gz: cb0866fb85465274cd61ecbe4ff0aa19ac94d0c20f783838e268909b2ae0d43d9ebc16778a8a1ec24589e1c1441c347d45d84079ac6dbc3f1ef3a6e8da26fafe
+  data.tar.gz: 129331534bbe57502166e569978701dc21bad9f805f3d06c2c822ac0ea80c12f290f5366cc525fd31ca91ac3a088119460127a197b9c0e2f85cc2b5b96eaf7c6

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+0.14.6 / 2015-09-29
+==================
+  * Updated to use the `pusher-signature` gem instead of `signature`.
+    This resolves namespace related issues.
 
 0.14.5 / 2015-05-11
 ==================

data/README.md

@@ -139,7 +139,7 @@ There are two main reasons for using the `_async` methods:
 
 Asynchronous calls are supported either by using an event loop (eventmachine, preferred), or via a thread.
 
-The following methods are available (in each case the calling iterface matches the non-async version):
+The following methods are available (in each case the calling interface matches the non-async version):
 
 * `Pusher.get_async`
 * `Pusher.post_async`

data/lib/pusher/client.rb

@@ -1,4 +1,4 @@
-require 'signature'
+require 'pusher-signature'
 
 module Pusher
   class Client
@@ -30,7 +30,7 @@ module Pusher
 
     # @private Returns the authentication token for the client
     def authentication_token
-      Signature::Token.new(@key, @secret)
+      Pusher::Signature::Token.new(@key, @secret)
     end
 
     # @private Builds a url for this app, optionally appending a path

data/lib/pusher/request.rb

@@ -1,4 +1,4 @@
-require 'signature'
+require 'pusher-signature'
 require 'digest/md5'
 require 'multi_json'
 
@@ -16,7 +16,7 @@ module Pusher
         @head['Content-Type'] = 'application/json'
       end
 
-      request = Signature::Request.new(verb.to_s.upcase, uri.path, params)
+      request = Pusher::Signature::Request.new(verb.to_s.upcase, uri.path, params)
       request.sign(client.authentication_token)
       @params = request.signed_params
     end

data/pusher.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "pusher"
-  s.version     = "0.14.5"
+  s.version     = "0.14.6"
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Pusher"]
   s.email       = ["support@pusher.com"]
@@ -13,11 +13,11 @@ Gem::Specification.new do |s|
   s.license     = "MIT"
 
   s.add_dependency "multi_json", "~> 1.0"
-  s.add_dependency 'signature', "~> 0.1.8"
+  s.add_dependency 'pusher-signature', "~> 0.1.8"
   s.add_dependency "httpclient", "~> 2.5"
   s.add_dependency "jruby-openssl" if defined?(JRUBY_VERSION)
 
-  s.add_development_dependency "rspec", "~> 2.0"
+  s.add_development_dependency "rspec", "~> 3.0"
   s.add_development_dependency "webmock"
   s.add_development_dependency "em-http-request", "~> 1.1.0"
   s.add_development_dependency "rake"

data/spec/channel_spec.rb

@@ -28,7 +28,7 @@ describe Pusher::Channel do
 
   describe '#trigger!' do
     it "should use @client.trigger internally" do
-      @client.should_receive(:trigger)
+      expect(@client).to receive(:trigger)
       @channel.trigger('new_event', 'Some data')
     end
   end
@@ -37,16 +37,16 @@ describe Pusher::Channel do
     it "should log failure if error raised in http call" do
       stub_post_to_raise(HTTPClient::BadResponseError)
 
-      Pusher.logger.should_receive(:error).with("Exception from WebMock (HTTPClient::BadResponseError) (Pusher::HTTPError)")
-      Pusher.logger.should_receive(:debug) #backtrace
+      expect(Pusher.logger).to receive(:error).with("Exception from WebMock (HTTPClient::BadResponseError) (Pusher::HTTPError)")
+      expect(Pusher.logger).to receive(:debug) #backtrace
       channel = Pusher::Channel.new(@client.url, 'test_channel', @client)
       channel.trigger('new_event', 'Some data')
     end
 
     it "should log failure if Pusher returns an error response" do
       stub_post 401, "some signature info"
-      Pusher.logger.should_receive(:error).with("some signature info (Pusher::AuthenticationError)")
-      Pusher.logger.should_receive(:debug) #backtrace
+      expect(Pusher.logger).to receive(:error).with("some signature info (Pusher::AuthenticationError)")
+      expect(Pusher.logger).to receive(:debug) #backtrace
       channel = Pusher::Channel.new(@client.url, 'test_channel', @client)
       channel.trigger('new_event', 'Some data')
     end
@@ -54,30 +54,30 @@ describe Pusher::Channel do
 
   describe "#initialization" do
     it "should not be too long" do
-      lambda { @client['b'*201] }.should raise_error(Pusher::Error)
+      expect { @client['b'*201] }.to raise_error(Pusher::Error)
     end
 
     it "should not use bad characters" do
-      lambda { @client['*^!±`/""'] }.should raise_error(Pusher::Error)
+      expect { @client['*^!±`/""'] }.to raise_error(Pusher::Error)
     end
   end
 
   describe "#trigger_async" do
     it "should use @client.trigger_async internally" do
-      @client.should_receive(:trigger_async)
+      expect(@client).to receive(:trigger_async)
       @channel.trigger_async('new_event', 'Some data')
     end
   end
 
   describe '#info' do
     it "should call the Client#channel_info" do
-      @client.should_receive(:get).with("/channels/mychannel", anything)
+      expect(@client).to receive(:get).with("/channels/mychannel", anything)
       @channel = @client['mychannel']
       @channel.info
     end
 
     it "should assemble the requested attributes into the info option" do
-      @client.should_receive(:get).with(anything, {
+      expect(@client).to receive(:get).with(anything, {
         :info => "user_count,connection_count"
       })
       @channel = @client['presence-foo']
@@ -87,7 +87,7 @@ describe Pusher::Channel do
 
   describe '#users' do
     it "should call the Client#channel_users" do
-      @client.should_receive(:get).with("/channels/presence-mychannel/users").and_return({:users => {'id' => '4'}})
+      expect(@client).to receive(:get).with("/channels/presence-mychannel/users").and_return({:users => {'id' => '4'}})
       @channel = @client['presence-mychannel']
       @channel.users
     end
@@ -101,28 +101,28 @@ describe Pusher::Channel do
     it "should return an authentication string given a socket id" do
       auth = @channel.authentication_string('1.1')
 
-      auth.should == '12345678900000001:02259dff9a2a3f71ea8ab29ac0c0c0ef7996c8f3fd3702be5533f30da7d7fed4'
+      expect(auth).to eq('12345678900000001:02259dff9a2a3f71ea8ab29ac0c0c0ef7996c8f3fd3702be5533f30da7d7fed4')
     end
 
     it "should raise error if authentication is invalid" do
       [nil, ''].each do |invalid|
-        authentication_string(invalid).should raise_error Pusher::Error
+        expect(authentication_string(invalid)).to raise_error Pusher::Error
       end
     end
 
     describe 'with extra string argument' do
       it 'should be a string or nil' do
-        authentication_string('1.1', 123).should raise_error Pusher::Error
-        authentication_string('1.1', {}).should raise_error Pusher::Error
+        expect(authentication_string('1.1', 123)).to raise_error Pusher::Error
+        expect(authentication_string('1.1', {})).to raise_error Pusher::Error
 
-        authentication_string('1.1', 'boom').should_not raise_error
-        authentication_string('1.1', nil).should_not raise_error
+        expect(authentication_string('1.1', 'boom')).not_to raise_error
+        expect(authentication_string('1.1', nil)).not_to raise_error
       end
 
       it "should return an authentication string given a socket id and custom args" do
         auth = @channel.authentication_string('1.1', 'foobar')
 
-        auth.should == "12345678900000001:#{hmac(@client.secret, "1.1:test_channel:foobar")}"
+        expect(auth).to eq("12345678900000001:#{hmac(@client.secret, "1.1:test_channel:foobar")}")
       end
     end
   end
@@ -133,36 +133,36 @@ describe Pusher::Channel do
     end
 
     it 'should return a hash with signature including custom data and data as json string' do
-      MultiJson.stub(:encode).with(@custom_data).and_return 'a json string'
+      allow(MultiJson).to receive(:encode).with(@custom_data).and_return 'a json string'
 
       response = @channel.authenticate('1.1', @custom_data)
 
-      response.should == {
+      expect(response).to eq({
         :auth => "12345678900000001:#{hmac(@client.secret, "1.1:test_channel:a json string")}",
         :channel_data => 'a json string'
-      }
+      })
     end
 
     it 'should fail on invalid socket_ids' do
-      lambda {
+      expect {
         @channel.authenticate('1.1:')
-      }.should raise_error Pusher::Error
+      }.to raise_error Pusher::Error
 
-      lambda {
+      expect {
         @channel.authenticate('1.1foo', 'channel')
-      }.should raise_error Pusher::Error
+      }.to raise_error Pusher::Error
 
-      lambda {
+      expect {
         @channel.authenticate(':1.1')
-      }.should raise_error Pusher::Error
+      }.to raise_error Pusher::Error
 
-      lambda {
+      expect {
         @channel.authenticate('foo1.1', 'channel')
-      }.should raise_error Pusher::Error
+      }.to raise_error Pusher::Error
 
-      lambda {
+      expect {
         @channel.authenticate('foo', 'channel')
-      }.should raise_error Pusher::Error
+      }.to raise_error Pusher::Error
     end
   end
 end

data/spec/client_spec.rb

@@ -3,85 +3,6 @@ require 'spec_helper'
 require 'em-http'
 
 describe Pusher do
-  describe 'using multiple Client objects' do
-    before :each do
-      @client1 = Pusher::Client.new
-      @client2 = Pusher::Client.new
-
-      @client1.scheme = 'ws'
-      @client2.scheme = 'wss'
-      @client1.host = 'one'
-      @client2.host = 'two'
-      @client1.port = 81
-      @client2.port = 82
-      @client1.app_id = '1111'
-      @client2.app_id = '2222'
-      @client1.key = 'AAAA'
-      @client2.key = 'BBBB'
-      @client1.secret = 'aaaaaaaa'
-      @client2.secret = 'bbbbbbbb'
-    end
-
-    it "default should be configured automatically from environment variable" do
-      Pusher.default_client.url.host.should == "api.secret.pusherapp.com"
-    end
-
-    it "should send scheme messages to different objects" do
-      @client1.scheme.should_not == @client2.scheme
-    end
-
-    it "should send host messages to different objects" do
-      @client1.host.should_not == @client2.host
-    end
-
-    it "should send port messages to different objects" do
-      @client1.port.should_not == @client2.port
-    end
-
-    it "should send app_id messages to different objects" do
-      @client1.app_id.should_not == @client2.app_id
-    end
-
-    it "should send app_id messages to different objects" do
-      @client1.key.should_not == @client2.key
-    end
-
-    it "should send app_id messages to different objects" do
-      @client1.secret.should_not == @client2.secret
-    end
-
-    it "should send app_id messages to different objects" do
-      @client1.authentication_token.key.should_not == @client2.authentication_token.key
-      @client1.authentication_token.secret.should_not == @client2.authentication_token.secret
-    end
-
-    it "should send url messages to different objects" do
-      @client1.url.to_s.should_not == @client2.url.to_s
-      @client1.url = 'ws://one/apps/111'
-      @client2.url = 'wss://two/apps/222'
-      @client1.scheme.should_not == @client2.scheme
-      @client1.host.should_not == @client2.host
-      @client1.app_id.should_not == @client2.app_id
-    end
-
-    it "should send encrypted messages to different objects" do
-      @client1.encrypted = false
-      @client2.encrypted = true
-      @client1.scheme.should_not == @client2.scheme
-      @client1.port.should_not == @client2.port
-    end
-
-    it "should send [] messages to different objects" do
-      @client1['test'].should_not == @client2['test']
-    end
-
-    it "should send http_proxy messages to different objects" do
-      @client1.http_proxy = 'http://oneuser:onepassword@onehost:8080'
-      @client2.http_proxy = 'http://twouser:twopassword@twohost:8880'
-      @client1.http_proxy.should_not == @client2.http_proxy
-    end
-  end
-
   # The behaviour should be the same when using the Client object, or the
   # 'global' client delegated through the Pusher class
   [lambda { Pusher }, lambda { Pusher::Client.new }].each do |client_gen|
@@ -91,23 +12,23 @@ describe Pusher do
 
     describe 'default configuration' do
       it 'should be preconfigured for api host' do
-        @client.host.should == 'api.pusherapp.com'
+        expect(@client.host).to eq('api.pusherapp.com')
       end
 
       it 'should be preconfigured for port 80' do
-        @client.port.should == 80
+        expect(@client.port).to eq(80)
       end
 
       it 'should use standard logger if no other logger if defined' do
         Pusher.logger.debug('foo')
-        Pusher.logger.should be_kind_of(Logger)
+        expect(Pusher.logger).to be_kind_of(Logger)
       end
     end
 
     describe 'logging configuration' do
       it "can be configured to use any logger" do
         logger = double("ALogger")
-        logger.should_receive(:debug).with('foo')
+        expect(logger).to receive(:debug).with('foo')
         Pusher.logger = logger
         Pusher.logger.debug('foo')
         Pusher.logger = nil
@@ -118,24 +39,24 @@ describe Pusher do
       it "should be possible to configure everything by setting the url" do
         @client.url = "test://somekey:somesecret@api.staging.pusherapp.com:8080/apps/87"
 
-        @client.scheme.should == 'test'
-        @client.host.should == 'api.staging.pusherapp.com'
-        @client.port.should == 8080
-        @client.key.should == 'somekey'
-        @client.secret.should == 'somesecret'
-        @client.app_id.should == '87'
+        expect(@client.scheme).to eq('test')
+        expect(@client.host).to eq('api.staging.pusherapp.com')
+        expect(@client.port).to eq(8080)
+        expect(@client.key).to eq('somekey')
+        expect(@client.secret).to eq('somesecret')
+        expect(@client.app_id).to eq('87')
       end
 
       it "should override scheme and port when setting encrypted=true after url" do
         @client.url = "http://somekey:somesecret@api.staging.pusherapp.com:8080/apps/87"
         @client.encrypted = true
 
-        @client.scheme.should == 'https'
-        @client.port.should == 443
+        expect(@client.scheme).to eq('https')
+        expect(@client.port).to eq(443)
       end
 
       it "should fail on bad urls" do
-        expect { @client.url = "gopher/somekey:somesecret@://api.staging.pusherapp.co://m:8080\apps\87" }.to raise_error
+        expect { @client.url = "gopher/somekey:somesecret@://api.staging.pusherapp.co://m:8080\apps\87" }.to raise_error(URI::InvalidURIError)
       end
     end
 
@@ -143,7 +64,7 @@ describe Pusher do
       it "should be possible to configure everything by setting the http_proxy" do
         @client.http_proxy = 'http://someuser:somepassword@proxy.host.com:8080'
 
-        @client.proxy.should == {:scheme => 'http', :host => 'proxy.host.com', :port => 8080, :user => 'someuser', :password => 'somepassword'}
+        expect(@client.proxy).to eq({:scheme => 'http', :host => 'proxy.host.com', :port => 8080, :user => 'someuser', :password => 'somepassword'})
       end
     end
 
@@ -160,15 +81,15 @@ describe Pusher do
         end
 
         it 'should return a channel' do
-          @channel.should be_kind_of(Pusher::Channel)
+          expect(@channel).to be_kind_of(Pusher::Channel)
         end
 
         %w{app_id key secret}.each do |config|
           it "should raise exception if #{config} not configured" do
             @client.send("#{config}=", nil)
-            lambda {
+            expect {
               @client['test_channel']
-            }.should raise_error(Pusher::ConfigurationError)
+            }.to raise_error(Pusher::ConfigurationError)
           end
         end
       end
@@ -183,12 +104,12 @@ describe Pusher do
               "channel2" => {}
             })
           })
-          @client.channels.should == {
+          expect(@client.channels).to eq({
             :channels => {
               "channel1" => {},
               "channel2" => {}
             }
-          }
+          })
         end
       end
 
@@ -201,9 +122,9 @@ describe Pusher do
               'occupied' => false,
             })
           })
-          @client.channel_info('mychannel').should == {
+          expect(@client.channel_info('mychannel')).to eq({
             :occupied => false,
-          }
+          })
         end
       end
 
@@ -217,41 +138,41 @@ describe Pusher do
         end
 
         it "should call correct URL" do
-          @client.trigger(['mychannel'], 'event', {'some' => 'data'}).
-            should == {}
+          expect(@client.trigger(['mychannel'], 'event', {'some' => 'data'})).
+            to eq({})
         end
 
         it "should not allow too many channels" do
-          lambda {
+          expect {
             @client.trigger((0..11).map{|i| 'mychannel#{i}'},
               'event', {'some' => 'data'}, {
                 :socket_id => "12.34"
-              })}.should raise_error(Pusher::Error)
+              })}.to raise_error(Pusher::Error)
         end
 
         it "should pass any parameters in the body of the request" do
           @client.trigger(['mychannel', 'c2'], 'event', {'some' => 'data'}, {
             :socket_id => "12.34"
           })
-          WebMock.should have_requested(:post, @api_path).with { |req|
+          expect(WebMock).to have_requested(:post, @api_path).with { |req|
             parsed = MultiJson.decode(req.body)
-            parsed["name"].should == 'event'
-            parsed["channels"].should == ["mychannel", "c2"]
-            parsed["socket_id"].should == '12.34'
+            expect(parsed["name"]).to eq('event')
+            expect(parsed["channels"]).to eq(["mychannel", "c2"])
+            expect(parsed["socket_id"]).to eq('12.34')
           }
         end
 
         it "should convert non string data to JSON before posting" do
           @client.trigger(['mychannel'], 'event', {'some' => 'data'})
-          WebMock.should have_requested(:post, @api_path).with { |req|
-            MultiJson.decode(req.body)["data"].should == '{"some":"data"}'
+          expect(WebMock).to have_requested(:post, @api_path).with { |req|
+            expect(MultiJson.decode(req.body)["data"]).to eq('{"some":"data"}')
           }
         end
 
         it "should accept a single channel as well as an array" do
           @client.trigger('mychannel', 'event', {'some' => 'data'})
-          WebMock.should have_requested(:post, @api_path).with { |req|
-            MultiJson.decode(req.body)["channels"].should == ['mychannel']
+          expect(WebMock).to have_requested(:post, @api_path).with { |req|
+            expect(MultiJson.decode(req.body)["channels"]).to eq(['mychannel'])
           }
         end
       end
@@ -268,7 +189,7 @@ describe Pusher do
         it "should call correct URL" do
           EM.run {
             @client.trigger_async('mychannel', 'event', {'some' => 'data'}).callback { |r|
-              r.should == {}
+              expect(r).to eq({})
               EM.stop
             }
           }
@@ -279,8 +200,8 @@ describe Pusher do
             @client.trigger_async('mychannel', 'event', {'some' => 'data'}, {
               :socket_id => "12.34"
             }).callback {
-              WebMock.should have_requested(:post, @api_path).with { |req|
-                MultiJson.decode(req.body)["socket_id"].should == '12.34'
+              expect(WebMock).to have_requested(:post, @api_path).with { |req|
+                expect(MultiJson.decode(req.body)["socket_id"]).to eq('12.34')
               }
               EM.stop
             }
@@ -290,8 +211,8 @@ describe Pusher do
         it "should convert non string data to JSON before posting" do
           EM.run {
             @client.trigger_async('mychannel', 'event', {'some' => 'data'}).callback {
-              WebMock.should have_requested(:post, @api_path).with { |req|
-                MultiJson.decode(req.body)["data"].should == '{"some":"data"}'
+              expect(WebMock).to have_requested(:post, @api_path).with { |req|
+                expect(MultiJson.decode(req.body)["data"]).to eq('{"some":"data"}')
               }
               EM.stop
             }
@@ -311,13 +232,13 @@ describe Pusher do
 
           it "should use http by default" do
             call_api
-            WebMock.should have_requested(verb, %r{http://api.pusherapp.com/apps/20/path})
+            expect(WebMock).to have_requested(verb, %r{http://api.pusherapp.com/apps/20/path})
           end
 
           it "should use https if configured" do
             @client.encrypted = true
             call_api
-            WebMock.should have_requested(verb, %r{https://api.pusherapp.com})
+            expect(WebMock).to have_requested(verb, %r{https://api.pusherapp.com})
           end
 
           it "should format the respose hash with symbols at first level" do
@@ -325,9 +246,9 @@ describe Pusher do
               :status => 200,
               :body => MultiJson.encode({'something' => {'a' => 'hash'}})
             })
-            call_api.should == {
+            expect(call_api).to eq({
               :something => {'a' => 'hash'}
-            }
+            })
           end
 
           it "should catch all http exceptions and raise a Pusher::HTTPError wrapping the original error" do
@@ -340,35 +261,35 @@ describe Pusher do
               error = e
             end
 
-            error.class.should == Pusher::HTTPError
-            error.should be_kind_of(Pusher::Error)
-            error.message.should == 'Exception from WebMock (HTTPClient::TimeoutError)'
-            error.original_error.class.should == HTTPClient::TimeoutError
+            expect(error.class).to eq(Pusher::HTTPError)
+            expect(error).to be_kind_of(Pusher::Error)
+            expect(error.message).to eq('Exception from WebMock (HTTPClient::TimeoutError)')
+            expect(error.original_error.class).to eq(HTTPClient::TimeoutError)
           end
 
           it "should raise Pusher::Error if call returns 400" do
             stub_request(verb, @url_regexp).to_return({:status => 400})
-            lambda { call_api }.should raise_error(Pusher::Error)
+            expect { call_api }.to raise_error(Pusher::Error)
           end
 
           it "should raise AuthenticationError if pusher returns 401" do
             stub_request(verb, @url_regexp).to_return({:status => 401})
-            lambda { call_api }.should raise_error(Pusher::AuthenticationError)
+            expect { call_api }.to raise_error(Pusher::AuthenticationError)
           end
 
           it "should raise Pusher::Error if pusher returns 404" do
             stub_request(verb, @url_regexp).to_return({:status => 404})
-            lambda { call_api }.should raise_error(Pusher::Error, '404 Not found (/apps/20/path)')
+            expect { call_api }.to raise_error(Pusher::Error, '404 Not found (/apps/20/path)')
           end
 
           it "should raise Pusher::Error if pusher returns 407" do
             stub_request(verb, @url_regexp).to_return({:status => 407})
-            lambda { call_api }.should raise_error(Pusher::Error, 'Proxy Authentication Required')
+            expect { call_api }.to raise_error(Pusher::Error, 'Proxy Authentication Required')
           end
 
           it "should raise Pusher::Error if pusher returns 500" do
             stub_request(verb, @url_regexp).to_return({:status => 500, :body => "some error"})
-            lambda { call_api }.should raise_error(Pusher::Error, 'Unknown error (status code 500): some error')
+            expect { call_api }.to raise_error(Pusher::Error, 'Unknown error (status code 500): some error')
           end
         end
       end
@@ -393,23 +314,23 @@ describe Pusher do
 
             it "should use http by default" do
               call_api
-              WebMock.should have_requested(verb, %r{http://api.pusherapp.com/apps/20/path})
+              expect(WebMock).to have_requested(verb, %r{http://api.pusherapp.com/apps/20/path})
             end
 
             it "should use https if configured" do
               @client.encrypted = true
               call_api
-              WebMock.should have_requested(verb, %r{https://api.pusherapp.com})
+              expect(WebMock).to have_requested(verb, %r{https://api.pusherapp.com})
             end
 
             # Note that the raw httpclient connection object is returned and
             # the response isn't handled (by handle_response) in the normal way.
             it "should return a httpclient connection object" do
               connection = call_api
-              connection.finished?.should be_true
+              expect(connection.finished?).to be_truthy
               response = connection.pop
-              response.status.should == 200
-              response.body.read.should == "{}"
+              expect(response.status).to eq(200)
+              expect(response.body.read).to eq("{}")
             end
           end
         end
@@ -429,7 +350,7 @@ describe Pusher do
             it "should use http by default" do
               EM.run {
                 call_api.callback {
-                  WebMock.should have_requested(verb, %r{http://api.pusherapp.com/apps/20/path})
+                  expect(WebMock).to have_requested(verb, %r{http://api.pusherapp.com/apps/20/path})
                   EM.stop
                 }
               }
@@ -439,7 +360,7 @@ describe Pusher do
               EM.run {
                 @client.encrypted = true
                 call_api.callback {
-                  WebMock.should have_requested(verb, %r{https://api.pusherapp.com})
+                  expect(WebMock).to have_requested(verb, %r{https://api.pusherapp.com})
                   EM.stop
                 }
               }
@@ -452,9 +373,9 @@ describe Pusher do
                   :body => MultiJson.encode({'something' => {'a' => 'hash'}})
                 })
                 call_api.callback { |response|
-                  response.should == {
+                  expect(response).to eq({
                     :something => {'a' => 'hash'}
-                  }
+                  })
                   EM.stop
                 }
               }
@@ -465,7 +386,7 @@ describe Pusher do
                 stub_request(verb, @url_regexp).to_return({:status => 400})
 
                 call_api.errback { |e|
-                  e.class.should == Pusher::Error
+                  expect(e.class).to eq(Pusher::Error)
                   EM.stop
                 }.callback {
                   fail

data/spec/spec_helper.rb

@@ -7,7 +7,6 @@ end
 ENV['PUSHER_URL']= 'http://some:secret@api.secret.pusherapp.com:441/apps/54'
 
 require 'rspec'
-require 'rspec/autorun'
 require 'em-http' # As of webmock 1.4.0, em-http must be loaded first
 require 'webmock/rspec'
 

data/spec/web_hook_spec.rb

@@ -22,9 +22,9 @@ describe Pusher::WebHook do
         'rack.input' => StringIO.new(MultiJson.encode(@hook_data))
       })
       wh = Pusher::WebHook.new(request)
-      wh.key.should == '1234'
-      wh.signature.should == 'asdf'
-      wh.data.should == @hook_data
+      expect(wh.key).to eq('1234')
+      expect(wh.signature).to eq('asdf')
+      expect(wh.data).to eq(@hook_data)
     end
 
     it "can be initialized with a hash" do
@@ -35,9 +35,9 @@ describe Pusher::WebHook do
         :body => MultiJson.encode(@hook_data),
       }
       wh = Pusher::WebHook.new(request)
-      wh.key.should == '1234'
-      wh.signature.should == 'asdf'
-      wh.data.should == @hook_data
+      expect(wh.key).to eq('1234')
+      expect(wh.signature).to eq('asdf')
+      expect(wh.data).to eq(@hook_data)
     end
   end
 
@@ -58,14 +58,14 @@ describe Pusher::WebHook do
     it "should validate" do
       @client.key = '1234'
       @client.secret = 'asdf'
-      @wh.should be_valid
+      expect(@wh).to be_valid
     end
 
     it "should not validate if key is wrong" do
       @client.key = '12345'
       @client.secret = 'asdf'
-      Pusher.logger.should_receive(:warn).with("Received webhook with unknown key: 1234")
-      @wh.should_not be_valid
+      expect(Pusher.logger).to receive(:warn).with("Received webhook with unknown key: 1234")
+      expect(@wh).not_to be_valid
     end
 
     it "should not validate if secret is wrong" do
@@ -73,45 +73,45 @@ describe Pusher::WebHook do
       @client.secret = 'asdfxxx'
       digest = OpenSSL::Digest::SHA256.new
       expected = OpenSSL::HMAC.hexdigest(digest, @client.secret, @body)
-      Pusher.logger.should_receive(:warn).with("Received WebHook with invalid signature: got #{@wh.signature}, expected #{expected}")
-      @wh.should_not be_valid
+      expect(Pusher.logger).to receive(:warn).with("Received WebHook with invalid signature: got #{@wh.signature}, expected #{expected}")
+      expect(@wh).not_to be_valid
     end
 
     it "should validate with an extra token" do
       @client.key = '12345'
       @client.secret = 'xxx'
-      @wh.valid?({:key => '1234', :secret => 'asdf'}).should be_true
+      expect(@wh.valid?({:key => '1234', :secret => 'asdf'})).to be_truthy
     end
 
     it "should validate with an array of extra tokens" do
       @client.key = '123456'
       @client.secret = 'xxx'
-      @wh.valid?([
+      expect(@wh.valid?([
         {:key => '12345', :secret => 'wtf'},
         {:key => '1234', :secret => 'asdf'}
-      ]).should be_true
+      ])).to be_truthy
     end
 
     it "should not validate if all keys are wrong with extra tokens" do
       @client.key = '123456'
       @client.secret = 'asdf'
-      Pusher.logger.should_receive(:warn).with("Received webhook with unknown key: 1234")
-      @wh.valid?({:key => '12345', :secret => 'asdf'}).should be_false
+      expect(Pusher.logger).to receive(:warn).with("Received webhook with unknown key: 1234")
+      expect(@wh.valid?({:key => '12345', :secret => 'asdf'})).to be_falsey
     end
 
     it "should not validate if secret is wrong with extra tokens" do
       @client.key = '123456'
       @client.secret = 'asdfxxx'
-      Pusher.logger.should_receive(:warn).with(/Received WebHook with invalid signature/)
-      @wh.valid?({:key => '1234', :secret => 'wtf'}).should be_false
+      expect(Pusher.logger).to receive(:warn).with(/Received WebHook with invalid signature/)
+      expect(@wh.valid?({:key => '1234', :secret => 'wtf'})).to be_falsey
     end
 
     it "should expose events" do
-      @wh.events.should == @hook_data["events"]
+      expect(@wh.events).to eq(@hook_data["events"])
     end
 
     it "should expose time" do
-      @wh.time.should == Time.at(123.456)
+      expect(@wh.time).to eq(Time.at(123.456))
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pusher
 version: !ruby/object:Gem::Version
-  version: 0.14.5
+  version: 0.14.6
 platform: ruby
 authors:
 - Pusher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-11 00:00:00.000000000 Z
+date: 2015-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: signature
+  name: pusher-signature
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -170,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Pusher API client