pusher-fake 1.6.0 → 1.7.0

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

@@ -1,27 +1,33 @@
 require "spec_helper"
 
 describe PusherFake::Configuration do
-  it { should have_configuration_option(:app_id).with_default("PUSHER_APP_ID") }
   it { should have_configuration_option(:key).with_default("PUSHER_API_KEY") }
   it { should have_configuration_option(:logger).with_default(STDOUT.to_io) }
-  it { should have_configuration_option(:secret).with_default("PUSHER_API_SECRET") }
   it { should have_configuration_option(:verbose).with_default(false) }
   it { should have_configuration_option(:webhooks).with_default([]) }
 
-  it "should have configuration option :socket_options" do
+  it do
+    should have_configuration_option(:app_id).with_default("PUSHER_APP_ID")
+  end
+
+  it do
+    should have_configuration_option(:secret).with_default("PUSHER_API_SECRET")
+  end
+
+  it "has configuration option :socket_options" do
     expect(subject.socket_options).to be_a(Hash)
     expect(subject.socket_options[:host]).to eq("127.0.0.1")
     expect(subject.socket_options[:port]).to be_a(Integer)
   end
 
-  it "should have configuration option :web_options" do
+  it "has configuration option :web_options" do
     expect(subject.web_options).to be_a(Hash)
     expect(subject.web_options[:host]).to eq("127.0.0.1")
     expect(subject.web_options[:port]).to be_a(Integer)
   end
 
   it "defaults socket and web ports to different values" do
-    expect(subject.socket_options[:port]).to_not eq(subject.web_options[:port])
+    expect(subject.socket_options[:port]).not_to eq(subject.web_options[:port])
   end
 end
 

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

@@ -1,10 +1,10 @@
 require "spec_helper"
 
 shared_examples_for "#process" do
-  let(:json) { double }
-
   subject { PusherFake::Connection.new(double) }
 
+  let(:json) { double }
+
   before do
     allow(PusherFake).to receive(:log)
     allow(MultiJson).to receive(:load).and_return(message)
@@ -19,14 +19,15 @@ shared_examples_for "#process" do
   it "logs receiving the event" do
     subject.process(json)
 
-    expect(PusherFake).to have_received(:log).with("RECV #{subject.id}: #{message}")
+    expect(PusherFake).to have_received(:log)
+      .with("RECV #{subject.id}: #{message}")
   end
 end
 
 describe PusherFake::Connection do
-  let(:socket) { double }
+  subject { described_class }
 
-  subject { PusherFake::Connection }
+  let(:socket) { double }
 
   it "assigns the provided socket" do
     connection = subject.new(socket)
@@ -36,15 +37,18 @@ describe PusherFake::Connection do
 end
 
 describe PusherFake::Connection, "#emit" do
+  subject { described_class.new(socket) }
+
   let(:data)         { { some: "data", good: true } }
   let(:json)         { MultiJson.dump(message) }
   let(:event)        { "name" }
-  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)) }
 
-  subject { PusherFake::Connection.new(socket) }
+  let(:socket) do
+    instance_double(EventMachine::WebSocket::Connection, send: nil)
+  end
 
   before do
     allow(PusherFake).to receive(:log)
@@ -65,14 +69,15 @@ describe PusherFake::Connection, "#emit" do
   it "logs sending the event" do
     subject.emit(event, data)
 
-    expect(PusherFake).to have_received(:log).with("SEND #{subject.id}: #{message}")
+    expect(PusherFake).to have_received(:log)
+      .with("SEND #{subject.id}: #{message}")
   end
 end
 
 describe PusherFake::Connection, "#establish" do
-  let(:socket) { double }
+  subject { described_class.new(socket) }
 
-  subject { PusherFake::Connection.new(socket) }
+  let(:socket) { double }
 
   before do
     allow(subject).to receive(:emit)
@@ -82,15 +87,16 @@ describe PusherFake::Connection, "#establish" do
     subject.establish
 
     expect(subject).to have_received(:emit)
-      .with("pusher:connection_established", socket_id: subject.id, activity_timeout: 120)
+      .with("pusher:connection_established",
+            socket_id: subject.id, activity_timeout: 120)
   end
 end
 
 describe PusherFake::Connection, "#id" do
-  let(:id)     { "123.456" }
-  let(:socket) { double(object_id: 123456) }
+  subject { described_class.new(socket) }
 
-  subject { PusherFake::Connection.new(socket) }
+  let(:id)     { "123.456" }
+  let(:socket) { instance_double(Object, object_id: 123_456) }
 
   it "returns the object ID of the socket" do
     expect(subject.id).to eq(id)
@@ -101,9 +107,12 @@ 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) { double(:channel, add: nil) }
     let(:message) { { event: "pusher:subscribe", data: data } }
 
+    let(:channel) do
+      instance_double(PusherFake::Channel::Presence, add: nil)
+    end
+
     before do
       allow(PusherFake::Channel).to receive(:factory).and_return(channel)
     end
@@ -125,9 +134,12 @@ end
 describe PusherFake::Connection, "#process, with an unsubscribe event" do
   it_should_behave_like "#process" do
     let(:name)    { "channel" }
-    let(:channel) { double(:channel, remove: nil) }
     let(:message) { { event: "pusher:unsubscribe", channel: name } }
 
+    let(:channel) do
+      instance_double(PusherFake::Channel::Presence, remove: nil)
+    end
+
     before do
       allow(PusherFake::Channel).to receive(:factory).and_return(channel)
     end
@@ -158,7 +170,7 @@ describe PusherFake::Connection, "#process, with a ping event" do
     it "does not create a channel" do
       subject.process(json)
 
-      expect(PusherFake::Channel).to_not have_received(:factory)
+      expect(PusherFake::Channel).not_to have_received(:factory)
     end
 
     it "emits a pong event" do
@@ -174,9 +186,13 @@ describe PusherFake::Connection, "#process, with a client event" do
     let(:data)    { {} }
     let(:name)    { "channel" }
     let(:event)   { "client-hello-world" }
-    let(:channel) { double(:channel, emit: nil, includes?: nil, is_a?: true) }
     let(:message) { { event: event, data: data, channel: name } }
 
+    let(:channel) do
+      instance_double(PusherFake::Channel::Private,
+                      emit: nil, includes?: nil, is_a?: true)
+    end
+
     before do
       allow(subject).to receive(:trigger)
       allow(PusherFake::Channel).to receive(:factory).and_return(channel)
@@ -191,7 +207,8 @@ describe PusherFake::Connection, "#process, with a client event" do
     it "ensures the channel is private" do
       subject.process(json)
 
-      expect(channel).to have_received(:is_a?).with(PusherFake::Channel::Private)
+      expect(channel).to have_received(:is_a?)
+        .with(PusherFake::Channel::Private)
     end
 
     it "checks if the connection is in the channel" do
@@ -200,48 +217,57 @@ describe PusherFake::Connection, "#process, with a client event" do
       expect(channel).to have_received(:includes?).with(subject)
     end
 
-    it "emits the event to the channel when the connection is in the channel" do
+    it "emits the event when the connection is in the channel" do
       allow(channel).to receive(:includes?).and_return(true)
 
       subject.process(json)
 
-      expect(channel).to have_received(:emit).with(event, data, socket_id: subject.id)
+      expect(channel).to have_received(:emit)
+        .with(event, data, socket_id: subject.id)
     end
 
-    it "does not emit the event to the channel when the channel is not private" do
+    it "does not emit the event when the channel is not private" do
       allow(channel).to receive(:is_a?).and_return(false)
       allow(channel).to receive(:includes?).and_return(true)
 
       subject.process(json)
 
-      expect(channel).to_not have_received(:emit)
+      expect(channel).not_to have_received(:emit)
     end
 
-    it "does not emit the event to the channel when the connection is not in the channel" do
+    it "does not emit the event when the connection is not in the channel" do
       allow(channel).to receive(:includes?).and_return(false)
 
       subject.process(json)
 
-      expect(channel).to_not have_received(:emit)
+      expect(channel).not_to have_received(:emit)
     end
   end
 end
 
-describe PusherFake::Connection, "#process, with a client event trigger a webhook" do
+describe PusherFake::Connection,
+         "#process, with a client event trigger a webhook" do
   it_should_behave_like "#process" do
     let(:data)    { { example: "data" } }
     let(:name)    { "channel" }
     let(:event)   { "client-hello-world" }
     let(:user_id) { 1 }
-    let(:channel) { double(:channel, name: name, emit: nil, includes?: nil) }
+    let(:members) { { subject => { user_id: user_id } } }
     let(:message) { { event: event, channel: name } }
     let(:options) { { channel: name, event: event, socket_id: subject.id } }
 
+    let(:channel) do
+      instance_double(PusherFake::Channel::Presence,
+                      name: name, emit: nil, includes?: nil)
+    end
+
     before do
       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)
+      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.
       allow(Thread).to receive(:new).and_yield
@@ -261,18 +287,18 @@ describe PusherFake::Connection, "#process, with a client event trigger a webhoo
 
       subject.process(json)
 
-      expect(channel).to have_received(:trigger).
-        with("client_event", options.merge(data: MultiJson.dump(data))).once
+      expect(channel).to have_received(:trigger)
+        .with("client_event", options.merge(data: MultiJson.dump(data))).once
     end
 
     it "includes user ID in event when on a presence channel" do
-      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 } })
+      allow(channel).to receive(:is_a?).and_return(true)
+      allow(channel).to receive(:members).and_return(members)
 
       subject.process(json)
 
-      expect(channel).to have_received(:trigger).
-        with("client_event", options.merge(user_id: user_id)).once
+      expect(channel).to have_received(:trigger)
+        .with("client_event", options.merge(user_id: user_id)).once
     end
   end
 end
@@ -282,23 +308,23 @@ describe PusherFake::Connection, "#process, with an unknown event" do
     let(:data)    { {} }
     let(:name)    { "channel" }
     let(:event)   { "hello-world" }
-    let(:channel) { double(:channel, emit: nil) }
+    let(:channel) { instance_double(PusherFake::Channel::Public, emit: nil) }
     let(:message) { { event: event, data: data, channel: name } }
 
     before do
       allow(PusherFake::Channel).to receive(:factory).and_return(channel)
     end
 
-    it "creates a channel from the event data" do
+    it "does not create a channel" do
       subject.process(json)
 
-      expect(PusherFake::Channel).to have_received(:factory).with(name)
+      expect(PusherFake::Channel).not_to have_received(:factory)
     end
 
     it "does not emit the event" do
       subject.process(json)
 
-      expect(channel).to_not have_received(:emit)
+      expect(channel).not_to have_received(:emit)
     end
   end
 end

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

@@ -1,14 +1,14 @@
 require "spec_helper"
 
 shared_examples_for "an API request" do
+  subject { PusherFake::Server::Application }
+
   let(:hash)        { double }
   let(:string)      { double }
-  let(:request)     { double(:request, path: path) }
+  let(:request)     { instance_double(Rack::Request, path: path) }
   let(:response)    { double }
   let(:environment) { double }
 
-  subject { PusherFake::Server::Application }
-
   before do
     allow(response).to receive(:finish).and_return(response)
 
@@ -65,7 +65,26 @@ describe PusherFake::Server::Application, ".call, for triggering events" do
   end
 end
 
-describe PusherFake::Server::Application, ".call, for retrieving occupied channels" do
+describe PusherFake::Server::Application,
+         ".call, for triggering batch events" do
+  it_should_behave_like "an API request" do
+    let(:id)   { PusherFake.configuration.app_id }
+    let(:path) { "/apps/#{id}/batch_events" }
+
+    before do
+      allow(subject).to receive(:batch_events).and_return(hash)
+    end
+
+    it "emits batch events" do
+      subject.call(environment)
+
+      expect(subject).to have_received(:batch_events).with(request)
+    end
+  end
+end
+
+describe PusherFake::Server::Application,
+         ".call, retrieving occupied channels" do
   it_should_behave_like "an API request" do
     let(:id)   { PusherFake.configuration.app_id }
     let(:path) { "/apps/#{id}/channels" }
@@ -83,8 +102,10 @@ describe PusherFake::Server::Application, ".call, for retrieving occupied channe
 end
 
 describe PusherFake::Server::Application, ".call, with unknown path" do
+  subject { described_class }
+
   let(:path)        { "/apps/fake/events" }
-  let(:request)     { double(:request, path: path) }
+  let(:request)     { instance_double(Rack::Request, path: path) }
   let(:message)     { "Unknown path: #{path}" }
   let(:response)    { double }
   let(:environment) { double }
@@ -96,8 +117,6 @@ describe PusherFake::Server::Application, ".call, with unknown path" do
     allow(Rack::Response).to receive(:new).and_return(response)
   end
 
-  subject { PusherFake::Server::Application }
-
   it "creates a request" do
     subject.call(environment)
 
@@ -124,15 +143,15 @@ describe PusherFake::Server::Application, ".call, with unknown path" do
 end
 
 describe PusherFake::Server::Application, ".call, raising an error" do
+  subject { described_class }
+
   let(:id)          { PusherFake.configuration.app_id }
   let(:path)        { "/apps/#{id}/channels" }
   let(:message)     { "Example error message." }
-  let(:request)     { double(:request, path: path) }
+  let(:request)     { instance_double(Rack::Request, path: path) }
   let(:response)    { double }
   let(:environment) { double }
 
-  subject { PusherFake::Server::Application }
-
   before do
     allow(subject).to receive(:channels).and_raise(message)
 
@@ -168,25 +187,35 @@ describe PusherFake::Server::Application, ".call, raising an error" do
 end
 
 describe PusherFake::Server::Application, ".events" do
-  let(:body)       { double(:body, read: event_json) }
+  subject { described_class }
+
+  let(:body)       { instance_double(StringIO, 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)    { double(:request, body: body) }
+  let(:request)    { instance_double(Rack::Request, body: body) }
   let(:channels)   { ["channel-1", "channel-2"] }
-  let(:channel_1)  { double(:channel, emit: true) }
-  let(:channel_2)  { double(:channel, emit: true) }
+  let(:channel_1)  { instance_double(PusherFake::Channel::Public, emit: true) }
+  let(:channel_2)  { instance_double(PusherFake::Channel::Public, emit: true) }
   let(:data_json)  { data.to_json }
   let(:socket_id)  { double }
   let(:event_json) { double }
 
-  subject { PusherFake::Server::Application }
+  let(:event) do
+    {
+      "channels"  => channels,
+      "name"      => name,
+      "data"      => data_json,
+      "socket_id" => socket_id
+    }
+  end
 
   before do
     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)
+    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,14 +233,10 @@ describe PusherFake::Server::Application, ".events" do
   it "handles invalid JSON for event data" do
     event["data"] = data = "fake"
 
-    allow(MultiJson).to receive(:load).with(data).and_raise(MultiJson::LoadError)
-
-    expect {
-      subject.events(request)
-    }.to_not raise_error
+    allow(MultiJson).to receive(:load)
+      .with(data).and_raise(MultiJson::LoadError)
 
-    expect(channel_1).to have_received(:emit).with(name, data, socket_id: socket_id)
-    expect(channel_2).to have_received(:emit).with(name, data, socket_id: socket_id)
+    expect { subject.events(request) }.not_to raise_error
   end
 
   it "creates channels by name" do
@@ -225,16 +250,91 @@ describe PusherFake::Server::Application, ".events" do
   it "emits the event to the channels" do
     subject.events(request)
 
-    expect(channel_1).to have_received(:emit).with(name, data, socket_id: socket_id)
-    expect(channel_2).to have_received(:emit).with(name, data, socket_id: socket_id)
+    expect(channel_1).to have_received(:emit)
+      .with(name, data, socket_id: socket_id)
+    expect(channel_2).to have_received(:emit)
+      .with(name, data, socket_id: socket_id)
   end
 end
 
-describe PusherFake::Server::Application, ".channels, requesting all channels" do
-  let(:request)  { double(:request, params: {}) }
-  let(:channels) { { "channel-1" => double, "channel-2" => double } }
+describe PusherFake::Server::Application, ".batch_events" do
+  subject { described_class }
 
-  subject { PusherFake::Server::Application }
+  let(:body)       { instance_double(StringIO, read: event_json) }
+  let(:data)       { { "example" => "data" } }
+  let(:name)       { "event-name" }
+  let(:request)    { instance_double(Rack::Request, body: body) }
+  let(:channels)   { ["channel-1", "channel-2"] }
+  let(:channel_1)  { instance_double(PusherFake::Channel::Public, emit: true) }
+  let(:channel_2)  { instance_double(PusherFake::Channel::Public, emit: true) }
+  let(:data_json)  { data.to_json }
+  let(:socket_id)  { double }
+  let(:event_json) { double }
+
+  let(:batch) do
+    {
+      "batch" => [{
+        "channels"  => channels,
+        "name"      => name,
+        "data"      => data_json,
+        "socket_id" => socket_id
+      }]
+    }
+  end
+
+  before do
+    allow(MultiJson).to receive(:load).with(event_json).and_return(batch)
+    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
+    subject.batch_events(request)
+
+    expect(MultiJson).to have_received(:load).with(event_json)
+  end
+
+  it "parses the event data as JSON" do
+    subject.batch_events(request)
+
+    expect(MultiJson).to have_received(:load).with(data_json)
+  end
+
+  it "handles invalid JSON for event data" do
+    batch["batch"].first["data"] = data = "fake"
+
+    allow(MultiJson).to receive(:load)
+      .with(data).and_raise(MultiJson::LoadError)
+
+    expect { subject.batch_events(request) }.not_to raise_error
+  end
+
+  it "creates channels by name" do
+    subject.batch_events(request)
+
+    channels.each do |channel|
+      expect(PusherFake::Channel).to have_received(:factory).with(channel)
+    end
+  end
+
+  it "emits the event to the channels" do
+    subject.batch_events(request)
+
+    expect(channel_1).to have_received(:emit)
+      .with(name, data, socket_id: socket_id)
+    expect(channel_2).to have_received(:emit)
+      .with(name, data, socket_id: socket_id)
+  end
+end
+
+describe PusherFake::Server::Application, ".channels, requesting all" do
+  subject { described_class }
+
+  let(:request)  { instance_double(Rack::Request, params: {}) }
+  let(:channels) { { "channel-1" => double, "channel-2" => double } }
 
   before do
     allow(PusherFake::Channel).to receive(:channels).and_return(channels)
@@ -243,17 +343,18 @@ describe PusherFake::Server::Application, ".channels, requesting all channels" d
   it "returns a hash of all the channels" do
     hash = subject.channels(request)
 
-    expect(hash).to eq({ channels: { "channel-1" => {}, "channel-2" => {} } })
+    expect(hash).to eq(channels: { "channel-1" => {}, "channel-2" => {} })
   end
 end
 
-describe PusherFake::Server::Application, ".channels, requesting channels with a filter" do
+describe PusherFake::Server::Application,
+         ".channels, requesting channels with a filter" do
+  subject { described_class }
+
   let(:params)   { { "filter_by_prefix" => "public-" } }
-  let(:request)  { double(:request, params: params) }
+  let(:request)  { instance_double(Rack::Request, params: params) }
   let(:channels) { { "public-1" => double, "presence-1" => double } }
 
-  subject { PusherFake::Server::Application }
-
   before do
     allow(PusherFake::Channel).to receive(:channels).and_return(channels)
   end
@@ -261,66 +362,78 @@ describe PusherFake::Server::Application, ".channels, requesting channels with a
   it "returns a hash of the channels matching the filter" do
     hash = subject.channels(request)
 
-    expect(hash).to eq({ channels: { "public-1" => {} } })
+    expect(hash).to eq(channels: { "public-1" => {} })
   end
 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)  { double(:request, params: params) }
-  let(:channel)  { double(:channel, connections: [double, double]) }
+describe PusherFake::Server::Application,
+         ".channels, requesting user count for channels with a filter" do
+  subject { described_class }
+
+  let(:request)  { instance_double(Rack::Request, params: params) }
   let(:channels) { { "public-1" => double, "presence-1" => channel } }
 
-  subject { PusherFake::Server::Application }
+  let(:channel) do
+    instance_double(PusherFake::Channel::Presence,
+                    connections: [double, double])
+  end
+
+  let(:params) do
+    { "filter_by_prefix" => "presence-", "info" => "user_count" }
+  end
 
   before do
     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
+  it "returns hash of channels matching the filter and includes user count" do
     hash = subject.channels(request)
 
-    expect(hash).to eq({ channels: { "presence-1" => { user_count: 2 } } })
+    expect(hash).to eq(channels: { "presence-1" => { user_count: 2 } })
   end
 end
 
-describe PusherFake::Server::Application, ".channels, requesting all channels with no channels occupied" do
-  let(:request)  { double(:request, params: {}) }
-  let(:channels) { nil }
+describe PusherFake::Server::Application,
+         ".channels, requesting all channels with no channels occupied" do
+  subject { described_class }
 
-  subject { PusherFake::Server::Application }
+  let(:request) { instance_double(Rack::Request, params: {}) }
 
   before do
-    allow(PusherFake::Channel).to receive(:channels).and_return(channels)
+    allow(PusherFake::Channel).to receive(:channels).and_return({})
   end
 
   it "returns a hash of no channels" do
     hash = subject.channels(request)
 
-    expect(hash).to eq({ channels: {} })
+    expect(hash).to eq(channels: {})
   end
 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) { double(:request, params: params) }
+describe PusherFake::Server::Application,
+         ".channels, requesting a user count on a non-presence channel" do
+  subject { described_class }
 
-  subject { PusherFake::Server::Application }
+  let(:params)  { { "filter_by_prefix" => "public-", "info" => "user_count" } }
+  let(:request) { instance_double(Rack::Request, params: params) }
 
   it "raises an error" do
-    expect {
+    expect do
       subject.channels(request)
-    }.to raise_error(subject::CHANNEL_FILTER_ERROR)
+    end.to raise_error(subject::CHANNEL_FILTER_ERROR)
   end
 end
 
 describe PusherFake::Server::Application, ".channel, for an occupied channel" do
+  subject { described_class }
+
   let(:name)     { "public-1" }
-  let(:request)  { double(:request, params: {}) }
-  let(:channel)  { double(:channel, connections: [double]) }
+  let(:request)  { instance_double(Rack::Request, params: {}) }
   let(:channels) { { name => channel } }
 
-  subject { PusherFake::Server::Application }
+  let(:channel) do
+    instance_double(PusherFake::Channel::Presence, connections: [double])
+  end
 
   before do
     allow(PusherFake::Channel).to receive(:channels).and_return(channels)
@@ -329,17 +442,20 @@ describe PusherFake::Server::Application, ".channel, for an occupied channel" do
   it "returns a hash with the occupied status" do
     hash = subject.channel(name, request)
 
-    expect(hash).to eq({ occupied: true })
+    expect(hash).to eq(occupied: true)
   end
 end
 
-describe PusherFake::Server::Application, ".channel, for an unoccupied channel" do
+describe PusherFake::Server::Application, ".channel, for unoccupied channel" do
+  subject { described_class }
+
   let(:name)     { "public-1" }
-  let(:request)  { double(:request, params: {}) }
-  let(:channel)  { double(:channel, connections: []) }
+  let(:request)  { instance_double(Rack::Request, params: {}) }
   let(:channels) { { name => channel } }
 
-  subject { PusherFake::Server::Application }
+  let(:channel) do
+    instance_double(PusherFake::Channel::Presence, connections: [])
+  end
 
   before do
     allow(PusherFake::Channel).to receive(:channels).and_return(channels)
@@ -348,15 +464,15 @@ describe PusherFake::Server::Application, ".channel, for an unoccupied channel"
   it "returns a hash with the occupied status" do
     hash = subject.channel(name, request)
 
-    expect(hash).to eq({ occupied: false })
+    expect(hash).to eq(occupied: false)
   end
 end
 
 describe PusherFake::Server::Application, ".channel, for an unknown channel" do
-  let(:request)  { double(:request, params: {}) }
-  let(:channels) { {} }
+  subject { described_class }
 
-  subject { PusherFake::Server::Application }
+  let(:request)  { instance_double(Rack::Request, params: {}) }
+  let(:channels) { {} }
 
   before do
     allow(PusherFake::Channel).to receive(:channels).and_return(channels)
@@ -365,18 +481,23 @@ describe PusherFake::Server::Application, ".channel, for an unknown channel" do
   it "returns a hash with the occupied status" do
     hash = subject.channel("fake", request)
 
-    expect(hash).to eq({ occupied: false })
+    expect(hash).to eq(occupied: false)
   end
 end
 
-describe PusherFake::Server::Application, ".channel, request user count for a presence channel" do
+describe PusherFake::Server::Application,
+         ".channel, request user count for a presence channel" do
+  subject { described_class }
+
   let(:name)     { "presence-1" }
   let(:params)   { { "info" => "user_count" } }
-  let(:request)  { double(:request, params: params) }
-  let(:channel)  { double(:channel, connections: [double, double]) }
+  let(:request)  { instance_double(Rack::Request, params: params) }
   let(:channels) { { name => channel } }
 
-  subject { PusherFake::Server::Application }
+  let(:channel) do
+    instance_double(PusherFake::Channel::Presence,
+                    connections: [double, double])
+  end
 
   before do
     allow(PusherFake::Channel).to receive(:channels).and_return(channels)
@@ -385,31 +506,35 @@ describe PusherFake::Server::Application, ".channel, request user count for a pr
   it "returns a hash with the occupied status" do
     hash = subject.channel(name, request)
 
-    expect(hash).to eq({ occupied: true, user_count: 2 })
+    expect(hash).to eq(occupied: true, user_count: 2)
   end
 end
 
-describe PusherFake::Server::Application, ".channel, requesting a user count on a non-presence channel" do
-  let(:params)  { { "info" => "user_count" } }
-  let(:request) { double(:request, params: params) }
+describe PusherFake::Server::Application,
+         ".channel, requesting a user count on a non-presence channel" do
+  subject { described_class }
 
-  subject { PusherFake::Server::Application }
+  let(:params)  { { "info" => "user_count" } }
+  let(:request) { instance_double(Rack::Request, params: params) }
 
   it "raises an error" do
-    expect {
+    expect do
       subject.channel("public-1", request)
-    }.to raise_error(subject::CHANNEL_USER_COUNT_ERROR)
+    end.to raise_error(subject::CHANNEL_USER_COUNT_ERROR)
   end
 end
 
 describe PusherFake::Server::Application, ".users, for an occupied channel" do
+  subject { described_class }
+
   let(:name)     { "public-1" }
-  let(:user_1)   { double(:user, id: "1") }
-  let(:user_2)   { double(:user, id: "2") }
-  let(:channel)  { double(:channel, connections: [user_1, user_2]) }
+  let(:user_1)   { instance_double(PusherFake::Connection, id: "1") }
+  let(:user_2)   { instance_double(PusherFake::Connection, id: "2") }
   let(:channels) { { name => channel } }
 
-  subject { PusherFake::Server::Application }
+  let(:channel) do
+    instance_double(PusherFake::Channel::Public, connections: [user_1, user_2])
+  end
 
   before do
     allow(PusherFake::Channel).to receive(:channels).and_return(channels)
@@ -418,19 +543,19 @@ describe PusherFake::Server::Application, ".users, for an occupied channel" do
   it "returns a hash with the occupied status" do
     hash = subject.users(name)
 
-    expect(hash).to eq({ users: [
-      { id: user_1.id },
-      { id: user_2.id }
-    ] })
+    expect(hash).to eq(users: [{ id: user_1.id }, { id: user_2.id }])
   end
 end
 
 describe PusherFake::Server::Application, ".users, for an empty channel" do
+  subject { described_class }
+
   let(:name)     { "public-1" }
-  let(:channel)  { double(:channel, connections: []) }
   let(:channels) { { name => channel } }
 
-  subject { PusherFake::Server::Application }
+  let(:channel) do
+    instance_double(PusherFake::Channel::Public, connections: [])
+  end
 
   before do
     allow(PusherFake::Channel).to receive(:channels).and_return(channels)
@@ -439,14 +564,14 @@ describe PusherFake::Server::Application, ".users, for an empty channel" do
   it "returns a hash with the occupied status" do
     hash = subject.users(name)
 
-    expect(hash).to eq({ users: [] })
+    expect(hash).to eq(users: [])
   end
 end
 
 describe PusherFake::Server::Application, ".users, for an unknown channel" do
-  let(:channels) { {} }
+  subject { described_class }
 
-  subject { PusherFake::Server::Application }
+  let(:channels) { {} }
 
   before do
     allow(PusherFake::Channel).to receive(:channels).and_return(channels)
@@ -455,6 +580,6 @@ describe PusherFake::Server::Application, ".users, for an unknown channel" do
   it "returns a hash with the occupied status" do
     hash = subject.users("fake")
 
-    expect(hash).to eq({ users: [] })
+    expect(hash).to eq(users: [])
   end
 end