pusher-fake 1.2.0 → 1.3.0

data/spec/lib/pusher-fake/channel_spec.rb

@@ -2,12 +2,12 @@ require "spec_helper"
 
 describe PusherFake::Channel, ".factory" do
   let(:name)    { "channel" }
-  let(:channel) { stub }
+  let(:channel) { double }
 
   subject { PusherFake::Channel }
 
   before do
-    PusherFake::Channel::Public.stubs(new: channel)
+    allow(PusherFake::Channel::Public).to receive(:new).and_return(channel)
   end
 
   after do
@@ -15,7 +15,7 @@ describe PusherFake::Channel, ".factory" do
   end
 
   it "caches the channel" do
-    PusherFake::Channel::Public.unstub(:new)
+    allow(PusherFake::Channel::Public).to receive(:new).and_call_original
 
     factory_1 = subject.factory(name)
     factory_2 = subject.factory(name)
@@ -38,12 +38,12 @@ end
 
 describe PusherFake::Channel, ".factory, for a private channel" do
   let(:name)    { "private-channel" }
-  let(:channel) { stub }
+  let(:channel) { double }
 
   subject { PusherFake::Channel }
 
   before do
-    PusherFake::Channel::Private.stubs(new: channel)
+    allow(PusherFake::Channel::Private).to receive(:new).and_return(channel)
   end
 
   after do
@@ -51,7 +51,7 @@ describe PusherFake::Channel, ".factory, for a private channel" do
   end
 
   it "caches the channel" do
-    PusherFake::Channel::Private.unstub(:new)
+    allow(PusherFake::Channel::Private).to receive(:new).and_call_original
 
     factory_1 = subject.factory(name)
     factory_2 = subject.factory(name)
@@ -74,12 +74,12 @@ end
 
 describe PusherFake::Channel, ".factory, for a presence channel" do
   let(:name)    { "presence-channel" }
-  let(:channel) { stub }
+  let(:channel) { double }
 
   subject { PusherFake::Channel }
 
   before do
-    PusherFake::Channel::Presence.stubs(new: channel)
+    allow(PusherFake::Channel::Presence).to receive(:new).and_return(channel)
   end
 
   after do
@@ -87,7 +87,7 @@ describe PusherFake::Channel, ".factory, for a presence channel" do
   end
 
   it "caches the channel" do
-    PusherFake::Channel::Presence.unstub(:new)
+    allow(PusherFake::Channel::Presence).to receive(:new).and_call_original
 
     factory_1 = subject.factory(name)
     factory_2 = subject.factory(name)
@@ -110,14 +110,14 @@ end
 
 describe PusherFake::Channel, ".remove" do
   let(:channels)   { { channel_1: channel_1, channel_2: channel_2 } }
-  let(:channel_1)  { stub(connections: stub(empty?: true), remove: nil) }
-  let(:channel_2)  { stub(connections: stub(empty?: false), remove: nil) }
-  let(:connection) { mock }
+  let(:channel_1)  { double(:channel, connections: double(:array, empty?: true), remove: nil) }
+  let(:channel_2)  { double(:channel, connections: double(:array, empty?: false), remove: nil) }
+  let(:connection) { double }
 
   subject { PusherFake::Channel }
 
   before do
-    subject.stubs(channels: channels)
+    allow(subject).to receive(:channels).and_return(channels)
   end
 
   it "removes the connection from all channels" do
@@ -140,7 +140,7 @@ describe PusherFake::Channel, ".remove" do
   end
 
   it "handles channels not being defined" do
-    subject.stubs(channels: nil)
+    allow(subject).to receive(:channels).and_return(nil)
 
     expect {
       subject.remove(connection)

data/spec/lib/pusher-fake/configuration_spec.rb

@@ -38,6 +38,12 @@ describe PusherFake::Configuration, "#to_options" do
     expect(options).to include(wsPort: subject.socket_options[:port])
   end
 
+  it "only enables the WebSocket transport" do
+    options = subject.to_options
+
+    expect(options).to include(enabledTransports: ["ws"])
+  end
+
   it "supports passing custom options" do
     options = subject.to_options(custom: "option")
 

data/spec/lib/pusher-fake/connection_spec.rb

@@ -1,13 +1,13 @@
 require "spec_helper"
 
 shared_examples_for "#process" do
-  let(:json) { stub }
+  let(:json) { double }
 
-  subject { PusherFake::Connection.new(stub) }
+  subject { PusherFake::Connection.new(double) }
 
   before do
-    PusherFake.stubs(:log)
-    MultiJson.stubs(load: message)
+    allow(PusherFake).to receive(:log)
+    allow(MultiJson).to receive(:load).and_return(message)
   end
 
   it "parses the JSON data" do
@@ -24,7 +24,7 @@ shared_examples_for "#process" do
 end
 
 describe PusherFake::Connection do
-  let(:socket) { stub }
+  let(:socket) { double }
 
   subject { PusherFake::Connection }
 
@@ -39,7 +39,7 @@ describe PusherFake::Connection, "#emit" do
   let(:data)         { { some: "data", good: true } }
   let(:json)         { MultiJson.dump(message) }
   let(:event)        { "name" }
-  let(:socket)       { stub(:send) }
+  let(:socket)       { double(:socket, send: nil) }
   let(:channel)      { "channel" }
   let(:message)      { { event: event, data: MultiJson.dump(data) } }
   let(:channel_json) { MultiJson.dump(message.merge(channel: channel)) }
@@ -47,7 +47,7 @@ describe PusherFake::Connection, "#emit" do
   subject { PusherFake::Connection.new(socket) }
 
   before do
-    PusherFake.stubs(:log)
+    allow(PusherFake).to receive(:log)
   end
 
   it "sends the event to the socket as JSON" do
@@ -70,12 +70,12 @@ describe PusherFake::Connection, "#emit" do
 end
 
 describe PusherFake::Connection, "#establish" do
-  let(:socket) { stub }
+  let(:socket) { double }
 
   subject { PusherFake::Connection.new(socket) }
 
   before do
-    subject.stubs(:emit)
+    allow(subject).to receive(:emit)
   end
 
   it "emits the connection established event with the connection ID" do
@@ -88,7 +88,7 @@ end
 
 describe PusherFake::Connection, "#id" do
   let(:id)     { socket.object_id.to_s }
-  let(:socket) { stub }
+  let(:socket) { double }
 
   subject { PusherFake::Connection.new(socket) }
 
@@ -101,11 +101,11 @@ describe PusherFake::Connection, "#process, with a subscribe event" do
   it_should_behave_like "#process" do
     let(:data)    { { channel: name, auth: "auth" } }
     let(:name)    { "channel" }
-    let(:channel) { stub(add: nil) }
+    let(:channel) { double(:channel, add: nil) }
     let(:message) { { event: "pusher:subscribe", data: data } }
 
     before do
-      PusherFake::Channel.stubs(factory: channel)
+      allow(PusherFake::Channel).to receive(:factory).and_return(channel)
     end
 
     it "creates a channel from the event data" do
@@ -125,11 +125,11 @@ end
 describe PusherFake::Connection, "#process, with an unsubscribe event" do
   it_should_behave_like "#process" do
     let(:name)    { "channel" }
-    let(:channel) { stub(remove: nil) }
+    let(:channel) { double(:channel, remove: nil) }
     let(:message) { { event: "pusher:unsubscribe", channel: name } }
 
     before do
-      PusherFake::Channel.stubs(factory: channel)
+      allow(PusherFake::Channel).to receive(:factory).and_return(channel)
     end
 
     it "creates a channel from the event data" do
@@ -151,13 +151,14 @@ describe PusherFake::Connection, "#process, with a ping event" do
     let(:message) { { event: "pusher:ping", data: {} } }
 
     before do
-      subject.stubs(:emit)
+      allow(subject).to receive(:emit)
+      allow(PusherFake::Channel).to receive(:factory)
     end
 
     it "does not create a channel" do
       subject.process(json)
 
-      expect(PusherFake::Channel).to have_received(:factory).never
+      expect(PusherFake::Channel).to_not have_received(:factory)
     end
 
     it "emits a pong event" do
@@ -173,12 +174,12 @@ describe PusherFake::Connection, "#process, with a client event" do
     let(:data)    { {} }
     let(:name)    { "channel" }
     let(:event)   { "client-hello-world" }
-    let(:channel) { stub(emit: nil, includes?: nil, is_a?: true) }
+    let(:channel) { double(:channel, emit: nil, includes?: nil, is_a?: true) }
     let(:message) { { event: event, data: data, channel: name } }
 
     before do
-      subject.stubs(:trigger)
-      PusherFake::Channel.stubs(factory: channel)
+      allow(subject).to receive(:trigger)
+      allow(PusherFake::Channel).to receive(:factory).and_return(channel)
     end
 
     it "creates a channel from the event data" do
@@ -200,7 +201,7 @@ describe PusherFake::Connection, "#process, with a client event" do
     end
 
     it "emits the event to the channel when the connection is in the channel" do
-      channel.stubs(includes?: true)
+      allow(channel).to receive(:includes?).and_return(true)
 
       subject.process(json)
 
@@ -208,19 +209,20 @@ describe PusherFake::Connection, "#process, with a client event" do
     end
 
     it "does not emit the event to the channel when the channel is not private" do
-      channel.stubs(includes?: true, is_a?: false)
+      allow(channel).to receive(:is_a?).and_return(false)
+      allow(channel).to receive(:includes?).and_return(true)
 
       subject.process(json)
 
-      expect(channel).to have_received(:emit).never
+      expect(channel).to_not have_received(:emit)
     end
 
     it "does not emit the event to the channel when the connection is not in the channel" do
-      channel.stubs(includes?: false)
+      allow(channel).to receive(:includes?).and_return(false)
 
       subject.process(json)
 
-      expect(channel).to have_received(:emit).never
+      expect(channel).to_not have_received(:emit)
     end
   end
 end
@@ -231,20 +233,20 @@ describe PusherFake::Connection, "#process, with a client event trigger a webhoo
     let(:name)    { "channel" }
     let(:event)   { "client-hello-world" }
     let(:user_id) { 1 }
-    let(:channel) { stub(name: name, emit: nil, includes?: nil) }
+    let(:channel) { double(:channel, name: name, emit: nil, includes?: nil) }
     let(:message) { { event: event, channel: name } }
     let(:options) { { channel: name, event: event, socket_id: subject.id } }
 
     before do
-      channel.stubs(:trigger)
-      channel.stubs(:includes?).with(subject).returns(true)
-      channel.stubs(:is_a?).with(PusherFake::Channel::Private).returns(true)
-      channel.stubs(:is_a?).with(PusherFake::Channel::Presence).returns(false)
+      allow(channel).to receive(:trigger)
+      allow(channel).to receive(:includes?).with(subject).and_return(true)
+      allow(channel).to receive(:is_a?).with(PusherFake::Channel::Private).and_return(true)
+      allow(channel).to receive(:is_a?).with(PusherFake::Channel::Presence).and_return(false)
 
       # NOTE: Hack to avoid race condition in unit tests.
-      Thread.stubs(:new).yields
+      allow(Thread).to receive(:new).and_yield
 
-      PusherFake::Channel.stubs(factory: channel)
+      allow(PusherFake::Channel).to receive(:factory).and_return(channel)
     end
 
     it "triggers the client event webhook" do
@@ -264,8 +266,8 @@ describe PusherFake::Connection, "#process, with a client event trigger a webhoo
     end
 
     it "includes user ID in event when on a presence channel" do
-      channel.stubs(:is_a?).with(PusherFake::Channel::Presence).returns(true)
-      channel.stubs(members: { subject => { user_id: user_id } })
+      allow(channel).to receive(:is_a?).with(PusherFake::Channel::Presence).and_return(true)
+      allow(channel).to receive(:members).and_return({ subject => { user_id: user_id } })
 
       subject.process(json)
 
@@ -280,11 +282,11 @@ describe PusherFake::Connection, "#process, with an unknown event" do
     let(:data)    { {} }
     let(:name)    { "channel" }
     let(:event)   { "hello-world" }
-    let(:channel) { stub(emit: nil) }
+    let(:channel) { double(:channel, emit: nil) }
     let(:message) { { event: event, data: data, channel: name } }
 
     before do
-      PusherFake::Channel.stubs(factory: channel)
+      allow(PusherFake::Channel).to receive(:factory).and_return(channel)
     end
 
     it "creates a channel from the event data" do
@@ -296,7 +298,7 @@ describe PusherFake::Connection, "#process, with an unknown event" do
     it "does not emit the event" do
       subject.process(json)
 
-      expect(channel).to have_received(:emit).never
+      expect(channel).to_not have_received(:emit)
     end
   end
 end

data/spec/lib/pusher-fake/server/application_spec.rb

@@ -1,20 +1,20 @@
 require "spec_helper"
 
 shared_examples_for "an API request" do
-  let(:hash)        { mock }
-  let(:string)      { mock }
-  let(:request)     { stub(path: path) }
-  let(:response)    { mock }
-  let(:environment) { mock }
+  let(:hash)        { double }
+  let(:string)      { double }
+  let(:request)     { double(:request, path: path) }
+  let(:response)    { double }
+  let(:environment) { double }
 
   subject { PusherFake::Server::Application }
 
   before do
-    response.stubs(finish: response)
+    allow(response).to receive(:finish).and_return(response)
 
-    MultiJson.stubs(dump: string)
-    Rack::Request.stubs(new: request)
-    Rack::Response.stubs(new: response)
+    allow(MultiJson).to receive(:dump).and_return(string)
+    allow(Rack::Request).to receive(:new).and_return(request)
+    allow(Rack::Response).to receive(:new).and_return(response)
   end
 
   it "creates a request" do
@@ -38,7 +38,7 @@ shared_examples_for "an API request" do
   it "finishes the response" do
     subject.call(environment)
 
-    expect(response).to have_received(:finish).with()
+    expect(response).to have_received(:finish).with(no_args)
   end
 
   it "returns the response" do
@@ -54,7 +54,7 @@ describe PusherFake::Server::Application, ".call, for triggering events" do
     let(:path) { "/apps/#{id}/events" }
 
     before do
-      subject.stubs(events: hash)
+      allow(subject).to receive(:events).and_return(hash)
     end
 
     it "emits events" do
@@ -71,7 +71,7 @@ describe PusherFake::Server::Application, ".call, for retrieving occupied channe
     let(:path) { "/apps/#{id}/channels" }
 
     before do
-      subject.stubs(channels: hash)
+      allow(subject).to receive(:channels).and_return(hash)
     end
 
     it "filters the occupied channels" do
@@ -84,16 +84,16 @@ end
 
 describe PusherFake::Server::Application, ".call, with unknown path" do
   let(:path)        { "/apps/fake/events" }
-  let(:request)     { stub(path: path) }
+  let(:request)     { double(:request, path: path) }
   let(:message)     { "Unknown path: #{path}" }
-  let(:response)    { mock }
-  let(:environment) { mock }
+  let(:response)    { double }
+  let(:environment) { double }
 
   before do
-    response.stubs(finish: response)
+    allow(response).to receive(:finish).and_return(response)
 
-    Rack::Request.stubs(new: request)
-    Rack::Response.stubs(new: response)
+    allow(Rack::Request).to receive(:new).and_return(request)
+    allow(Rack::Response).to receive(:new).and_return(response)
   end
 
   subject { PusherFake::Server::Application }
@@ -113,7 +113,7 @@ describe PusherFake::Server::Application, ".call, with unknown path" do
   it "finishes the response" do
     subject.call(environment)
 
-    expect(response).to have_received(:finish).with()
+    expect(response).to have_received(:finish).with(no_args)
   end
 
   it "returns the response" do
@@ -127,19 +127,19 @@ describe PusherFake::Server::Application, ".call, raising an error" do
   let(:id)          { PusherFake.configuration.app_id }
   let(:path)        { "/apps/#{id}/channels" }
   let(:message)     { "Example error message." }
-  let(:request)     { stub(path: path) }
-  let(:response)    { mock }
-  let(:environment) { mock }
+  let(:request)     { double(:request, path: path) }
+  let(:response)    { double }
+  let(:environment) { double }
 
   subject { PusherFake::Server::Application }
 
   before do
-    subject.stubs(:channels).raises(message)
+    allow(subject).to receive(:channels).and_raise(message)
 
-    response.stubs(finish: response)
+    allow(response).to receive(:finish).and_return(response)
 
-    Rack::Request.stubs(new: request)
-    Rack::Response.stubs(new: response)
+    allow(Rack::Request).to receive(:new).and_return(request)
+    allow(Rack::Response).to receive(:new).and_return(response)
   end
 
   it "creates a request" do
@@ -157,7 +157,7 @@ describe PusherFake::Server::Application, ".call, raising an error" do
   it "finishes the response" do
     subject.call(environment)
 
-    expect(response).to have_received(:finish).with()
+    expect(response).to have_received(:finish).with(no_args)
   end
 
   it "returns the response" do
@@ -168,25 +168,25 @@ describe PusherFake::Server::Application, ".call, raising an error" do
 end
 
 describe PusherFake::Server::Application, ".events" do
-  let(:body)       { stub(read: event_json) }
+  let(:body)       { double(:body, read: event_json) }
   let(:data)       { { "example" => "data" } }
   let(:name)       { "event-name" }
   let(:event)      { { "channels" => channels, "name" => name, "data" => data_json, "socket_id" => socket_id } }
-  let(:request)    { stub(body: body) }
+  let(:request)    { double(:request, body: body) }
   let(:channels)   { ["channel-1", "channel-2"] }
-  let(:channel_1)  { stub(emit: true) }
-  let(:channel_2)  { stub(emit: true) }
+  let(:channel_1)  { double(:channel, emit: true) }
+  let(:channel_2)  { double(:channel, emit: true) }
   let(:data_json)  { data.to_json }
-  let(:socket_id)  { stub }
-  let(:event_json) { mock }
+  let(:socket_id)  { double }
+  let(:event_json) { double }
 
   subject { PusherFake::Server::Application }
 
   before do
-    MultiJson.stubs(:load).with(event_json).returns(event)
-    MultiJson.stubs(:load).with(data_json).returns(data)
-    PusherFake::Channel.stubs(:factory).with(channels[0]).returns(channel_1)
-    PusherFake::Channel.stubs(:factory).with(channels[1]).returns(channel_2)
+    allow(MultiJson).to receive(:load).with(event_json).and_return(event)
+    allow(MultiJson).to receive(:load).with(data_json).and_return(data)
+    allow(PusherFake::Channel).to receive(:factory).with(channels[0]).and_return(channel_1)
+    allow(PusherFake::Channel).to receive(:factory).with(channels[1]).and_return(channel_2)
   end
 
   it "parses the request body as JSON" do
@@ -204,7 +204,7 @@ describe PusherFake::Server::Application, ".events" do
   it "handles invalid JSON for event data" do
     event["data"] = data = "fake"
 
-    MultiJson.stubs(:load).with(data).raises(MultiJson::LoadError)
+    allow(MultiJson).to receive(:load).with(data).and_raise(MultiJson::LoadError)
 
     expect {
       subject.events(request)
@@ -231,13 +231,13 @@ describe PusherFake::Server::Application, ".events" do
 end
 
 describe PusherFake::Server::Application, ".channels, requesting all channels" do
-  let(:request)  { stub(params: {}) }
-  let(:channels) { { "channel-1" => mock, "channel-2" => mock } }
+  let(:request)  { double(:request, params: {}) }
+  let(:channels) { { "channel-1" => double, "channel-2" => double } }
 
   subject { PusherFake::Server::Application }
 
   before do
-    PusherFake::Channel.stubs(channels: channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
 
   it "returns a hash of all the channels" do
@@ -249,13 +249,13 @@ end
 
 describe PusherFake::Server::Application, ".channels, requesting channels with a filter" do
   let(:params)   { { "filter_by_prefix" => "public-" } }
-  let(:request)  { stub(params: params) }
-  let(:channels) { { "public-1" => mock, "presence-1" => mock } }
+  let(:request)  { double(:request, params: params) }
+  let(:channels) { { "public-1" => double, "presence-1" => double } }
 
   subject { PusherFake::Server::Application }
 
   before do
-    PusherFake::Channel.stubs(channels: channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
 
   it "returns a hash of the channels matching the filter" do
@@ -267,14 +267,14 @@ end
 
 describe PusherFake::Server::Application, ".channels, requesting user count for channels with a filter" do
   let(:params)   { { "filter_by_prefix" => "presence-", "info" => "user_count" } }
-  let(:request)  { stub(params: params) }
-  let(:channel)  { stub(connections: [mock, mock]) }
-  let(:channels) { { "public-1" => mock, "presence-1" => channel } }
+  let(:request)  { double(:request, params: params) }
+  let(:channel)  { double(:channel, connections: [double, double]) }
+  let(:channels) { { "public-1" => double, "presence-1" => channel } }
 
   subject { PusherFake::Server::Application }
 
   before do
-    PusherFake::Channel.stubs(channels: channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
 
   it "returns a hash of the channels matching the filter and include the user count" do
@@ -285,13 +285,13 @@ describe PusherFake::Server::Application, ".channels, requesting user count for
 end
 
 describe PusherFake::Server::Application, ".channels, requesting all channels with no channels occupied" do
-  let(:request)  { stub(params: {}) }
+  let(:request)  { double(:request, params: {}) }
   let(:channels) { nil }
 
   subject { PusherFake::Server::Application }
 
   before do
-    PusherFake::Channel.stubs(channels: channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
 
   it "returns a hash of no channels" do
@@ -303,7 +303,7 @@ end
 
 describe PusherFake::Server::Application, ".channels, requesting a user count on a non-presence channel" do
   let(:params)  { { "filter_by_prefix" => "public-", "info" => "user_count" } }
-  let(:request) { stub(params: params) }
+  let(:request) { double(:request, params: params) }
 
   subject { PusherFake::Server::Application }
 
@@ -316,14 +316,14 @@ end
 
 describe PusherFake::Server::Application, ".channel, for an occupied channel" do
   let(:name)     { "public-1" }
-  let(:request)  { stub(params: {}) }
-  let(:channel)  { stub(connections: [mock]) }
+  let(:request)  { double(:request, params: {}) }
+  let(:channel)  { double(:channel, connections: [double]) }
   let(:channels) { { name => channel } }
 
   subject { PusherFake::Server::Application }
 
   before do
-    PusherFake::Channel.stubs(channels: channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
 
   it "returns a hash with the occupied status" do
@@ -335,14 +335,14 @@ end
 
 describe PusherFake::Server::Application, ".channel, for an unoccupied channel" do
   let(:name)     { "public-1" }
-  let(:request)  { stub(params: {}) }
-  let(:channel)  { stub(connections: []) }
+  let(:request)  { double(:request, params: {}) }
+  let(:channel)  { double(:channel, connections: []) }
   let(:channels) { { name => channel } }
 
   subject { PusherFake::Server::Application }
 
   before do
-    PusherFake::Channel.stubs(channels: channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
 
   it "returns a hash with the occupied status" do
@@ -353,13 +353,13 @@ describe PusherFake::Server::Application, ".channel, for an unoccupied channel"
 end
 
 describe PusherFake::Server::Application, ".channel, for an unknown channel" do
-  let(:request)  { stub(params: {}) }
+  let(:request)  { double(:request, params: {}) }
   let(:channels) { {} }
 
   subject { PusherFake::Server::Application }
 
   before do
-    PusherFake::Channel.stubs(channels: channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
 
   it "returns a hash with the occupied status" do
@@ -372,14 +372,14 @@ end
 describe PusherFake::Server::Application, ".channel, request user count for a presence channel" do
   let(:name)     { "presence-1" }
   let(:params)   { { "info" => "user_count" } }
-  let(:request)  { stub(params: params) }
-  let(:channel)  { stub(connections: [mock, mock]) }
+  let(:request)  { double(:request, params: params) }
+  let(:channel)  { double(:channel, connections: [double, double]) }
   let(:channels) { { name => channel } }
 
   subject { PusherFake::Server::Application }
 
   before do
-    PusherFake::Channel.stubs(channels: channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
 
   it "returns a hash with the occupied status" do
@@ -391,7 +391,7 @@ end
 
 describe PusherFake::Server::Application, ".channel, requesting a user count on a non-presence channel" do
   let(:params)  { { "info" => "user_count" } }
-  let(:request) { stub(params: params) }
+  let(:request) { double(:request, params: params) }
 
   subject { PusherFake::Server::Application }
 
@@ -404,15 +404,15 @@ end
 
 describe PusherFake::Server::Application, ".users, for an occupied channel" do
   let(:name)     { "public-1" }
-  let(:user_1)   { stub(id: "1") }
-  let(:user_2)   { stub(id: "2") }
-  let(:channel)  { stub(connections: [user_1, user_2]) }
+  let(:user_1)   { double(:user, id: "1") }
+  let(:user_2)   { double(:user, id: "2") }
+  let(:channel)  { double(:channel, connections: [user_1, user_2]) }
   let(:channels) { { name => channel } }
 
   subject { PusherFake::Server::Application }
 
   before do
-    PusherFake::Channel.stubs(channels: channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
 
   it "returns a hash with the occupied status" do
@@ -427,13 +427,13 @@ end
 
 describe PusherFake::Server::Application, ".users, for an empty channel" do
   let(:name)     { "public-1" }
-  let(:channel)  { stub(connections: []) }
+  let(:channel)  { double(:channel, connections: []) }
   let(:channels) { { name => channel } }
 
   subject { PusherFake::Server::Application }
 
   before do
-    PusherFake::Channel.stubs(channels: channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
 
   it "returns a hash with the occupied status" do
@@ -449,7 +449,7 @@ describe PusherFake::Server::Application, ".users, for an unknown channel" do
   subject { PusherFake::Server::Application }
 
   before do
-    PusherFake::Channel.stubs(channels: channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
 
   it "returns a hash with the occupied status" do