pusher-fake 1.2.0 → 1.3.0

data/spec/features/server/webhooks_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+feature "Receiving event webhooks" do
+  let(:channel)          { "room-1" }
+  let(:other_user)       { "Bob" }
+  let(:presence_channel) { "presence-room-1" }
+
+  before do
+    connect
+    connect_as(other_user)
+  end
+
+  scenario "occupying a channel" do
+    subscribe_to(channel)
+
+    expect($events).to include_event("channel_occupied", "channel" => channel)
+
+    subscribe_to_as(channel, other_user)
+
+    expect($events.size).to eq(1)
+  end
+
+  scenario "vacating a channel" do
+    subscribe_to(channel)
+    subscribe_to_as(channel, other_user)
+
+    unsubscribe_from(channel)
+
+    expect($events.size).to eq(1)
+
+    unsubscribe_from_as(channel, other_user)
+
+    expect($events).to include_event("channel_vacated", "channel" => channel)
+  end
+
+  scenario "subscribing to a presence channel" do
+    subscribe_to(presence_channel)
+
+    expect($events).to include_event("member_added", "channel" => presence_channel, "user_id" => user_id)
+
+    subscribe_to_as(presence_channel, other_user)
+
+    expect($events).to include_event("member_added", "channel" => presence_channel, "user_id" => user_id(other_user))
+  end
+
+  scenario "unsubscribing from a presence channel" do
+    subscribe_to(presence_channel)
+    subscribe_to_as(presence_channel, other_user)
+
+    unsubscribe_from(presence_channel)
+
+    expect($events).to include_event("member_added", "channel" => presence_channel, "user_id" => user_id)
+
+    unsubscribe_from_as(presence_channel, other_user)
+
+    expect($events).to include_event("member_added", "channel" => presence_channel, "user_id" => user_id(other_user))
+  end
+
+  protected
+
+  def include_event(event, options = {})
+    include(options.merge("name" => event))
+  end
+end

data/spec/lib/pusher-fake/channel/presence_spec.rb

@@ -20,8 +20,8 @@ describe PusherFake::Channel::Presence, "#add" do
   let(:data)              { { auth: authentication, channel_data: MultiJson.dump(channel_data) } }
   let(:name)              { "name" }
   let(:user_id)           { "1234" }
-  let(:connection)        { stub(emit: nil) }
-  let(:connections)       { stub(push: nil, length: 0) }
+  let(:connection)        { double(:connection, emit: nil) }
+  let(:connections)       { double(:connections, push: nil, length: 0) }
   let(:channel_data)      { { user_id: user_id } }
   let(:authentication)    { "auth" }
   let(:subscription_data) { { presence: { hash: {}, count: 1 } } }
@@ -29,13 +29,15 @@ describe PusherFake::Channel::Presence, "#add" do
   subject { PusherFake::Channel::Presence.new(name) }
 
   before do
-    PusherFake::Webhook.stubs(:trigger)
-    MultiJson.stubs(:load).returns(channel_data)
-    subject.stubs(connections: connections, emit: nil, subscription_data: subscription_data)
+    allow(PusherFake::Webhook).to receive(:trigger)
+    allow(MultiJson).to receive(:load).and_return(channel_data)
+    allow(subject).to receive(:connections).and_return(connections)
+    allow(subject).to receive(:emit).and_return(nil)
+    allow(subject).to receive(:subscription_data).and_return(subscription_data)
   end
 
   it "authorizes the connection" do
-    subject.stubs(authorized?: nil)
+    allow(subject).to receive(:authorized?).and_return(nil)
 
     subject.add(connection, data)
 
@@ -43,7 +45,7 @@ describe PusherFake::Channel::Presence, "#add" do
   end
 
   it "parses the channel_data when authorized" do
-    subject.stubs(authorized?: true)
+    allow(subject).to receive(:authorized?).and_return(true)
 
     subject.add(connection, data)
 
@@ -51,7 +53,7 @@ describe PusherFake::Channel::Presence, "#add" do
   end
 
   it "assigns the parsed channel_data to the members hash for the current connection" do
-    subject.stubs(authorized?: true)
+    allow(subject).to receive(:authorized?).and_return(true)
 
     subject.add(connection, data)
 
@@ -59,7 +61,7 @@ describe PusherFake::Channel::Presence, "#add" do
   end
 
   it "notifies the channel of the new member when authorized" do
-    subject.stubs(authorized?: true)
+    allow(subject).to receive(:authorized?).and_return(true)
 
     subject.add(connection, data)
 
@@ -67,7 +69,7 @@ describe PusherFake::Channel::Presence, "#add" do
   end
 
   it "successfully subscribes the connection when authorized" do
-    subject.stubs(authorized?: true)
+    allow(subject).to receive(:authorized?).and_return(true)
 
     subject.add(connection, data)
 
@@ -76,7 +78,7 @@ describe PusherFake::Channel::Presence, "#add" do
   end
 
   it "adds the connection to the channel when authorized" do
-    subject.stubs(authorized?: true)
+    allow(subject).to receive(:authorized?).and_return(true)
 
     subject.add(connection, data)
 
@@ -84,8 +86,8 @@ describe PusherFake::Channel::Presence, "#add" do
   end
 
   it "triggers channel occupied webhook for the first connection added when authorized" do
-    subject.unstub(:connections)
-    subject.stubs(authorized?: true)
+    allow(subject).to receive(:authorized?).and_return(true)
+    allow(subject).to receive(:connections).and_call_original
 
     2.times { subject.add(connection, data) }
 
@@ -93,7 +95,7 @@ describe PusherFake::Channel::Presence, "#add" do
   end
 
   it "triggers the member added webhook when authorized" do
-    subject.stubs(authorized?: true)
+    allow(subject).to receive(:authorized?).and_return(true)
 
     subject.add(connection, data)
 
@@ -101,7 +103,7 @@ describe PusherFake::Channel::Presence, "#add" do
   end
 
   it "unsuccessfully subscribes the connection when not authorized" do
-    subject.stubs(authorized?: false)
+    allow(subject).to receive(:authorized?).and_return(false)
 
     subject.add(connection, data)
 
@@ -109,35 +111,37 @@ describe PusherFake::Channel::Presence, "#add" do
   end
 
   it "does not trigger channel occupied webhook when not authorized" do
-    subject.unstub(:connections)
-    subject.stubs(authorized?: false)
+    allow(subject).to receive(:authorized?).and_return(false)
+    allow(subject).to receive(:connections).and_call_original
 
     2.times { subject.add(connection, data) }
 
-    expect(PusherFake::Webhook).to have_received(:trigger).never
+    expect(PusherFake::Webhook).to_not have_received(:trigger)
   end
 
   it "does not trigger the member added webhook when not authorized" do
-    subject.stubs(authorized?: false)
+    allow(subject).to receive(:authorized?).and_return(false)
 
     subject.add(connection, data)
 
-    expect(PusherFake::Webhook).to have_received(:trigger).never
+    expect(PusherFake::Webhook).to_not have_received(:trigger)
   end
 end
 
 describe PusherFake::Channel::Presence, "#remove" do
   let(:name)         { "name" }
   let(:user_id)      { "1234" }
-  let(:connection)   { stub }
+  let(:connection)   { double }
   let(:channel_data) { { user_id: user_id } }
 
   subject { PusherFake::Channel::Presence.new(name) }
 
   before do
-    PusherFake::Webhook.stubs(:trigger)
+    allow(PusherFake::Webhook).to receive(:trigger)
+    allow(subject).to receive(:connections).and_return([connection])
+    allow(subject).to receive(:emit).and_return(nil)
+
     subject.members[connection] = channel_data
-    subject.stubs(connections: [connection], emit: nil)
   end
 
   it "removes the connection from the channel" do
@@ -168,13 +172,15 @@ end
 describe PusherFake::Channel::Presence, "#remove, for an unsubscribed connection" do
   let(:name)         { "name" }
   let(:user_id)      { "1234" }
-  let(:connection)   { stub }
+  let(:connection)   { double }
   let(:channel_data) { { user_id: user_id } }
 
   subject { PusherFake::Channel::Presence.new(name) }
 
   before do
-    subject.stubs(connections: [], emit: nil, trigger: nil)
+    allow(subject).to receive(:connections).and_return([])
+    allow(subject).to receive(:emit).and_return(nil)
+    allow(subject).to receive(:trigger).and_return(nil)
   end
 
   it "does not raise an error" do
@@ -186,25 +192,25 @@ describe PusherFake::Channel::Presence, "#remove, for an unsubscribed connection
   it "does not trigger an event" do
     subject.remove(connection)
 
-    expect(PusherFake::Webhook).to have_received(:trigger).with("member_removed", channel: name, user_id: user_id).never
+    expect(subject).to_not have_received(:trigger).with("member_removed", channel: name, user_id: user_id)
   end
 
   it "does not emit an event" do
     subject.remove(connection)
 
-    expect(subject).to have_received(:emit).with("pusher_internal:member_removed", channel_data).never
+    expect(subject).to_not have_received(:emit).with("pusher_internal:member_removed", channel_data)
   end
 end
 
 describe PusherFake::Channel::Presence, "#subscription_data" do
   let(:other)   { { user_id: 2, name: "Beau" } }
   let(:member)  { { user_id: 1, name: "Bob" } }
-  let(:members) { { stub => member } }
+  let(:members) { { double => member } }
 
   subject { PusherFake::Channel::Presence.new("name") }
 
   before do
-    subject.stubs(members: members)
+    allow(subject).to receive(:members).and_return(members)
   end
 
   it "returns hash with presence information" do
@@ -219,7 +225,7 @@ describe PusherFake::Channel::Presence, "#subscription_data" do
   end
 
   it "handles multiple members" do
-    members[stub] = other
+    members[double] = other
 
     data = subject.subscription_data
 

data/spec/lib/pusher-fake/channel/private_spec.rb

@@ -11,19 +11,19 @@ end
 describe PusherFake::Channel::Private, "#add" do
   let(:data)           { { auth: authentication } }
   let(:name)           { "name" }
-  let(:connection)     { stub(emit: nil) }
-  let(:connections)    { stub(push: nil, length: 0) }
+  let(:connection)     { double(:connection, emit: nil) }
+  let(:connections)    { double(:connections, push: nil, length: 0) }
   let(:authentication) { "auth" }
 
   subject { PusherFake::Channel::Private.new(name) }
 
   before do
-    PusherFake::Webhook.stubs(:trigger)
-    subject.stubs(connections: connections)
+    allow(PusherFake::Webhook).to receive(:trigger)
+    allow(subject).to receive(:connections).and_return(connections)
   end
 
   it "authorizes the connection" do
-    subject.stubs(authorized?: nil)
+    allow(subject).to receive(:authorized?).and_return(nil)
 
     subject.add(connection, data)
 
@@ -31,7 +31,7 @@ describe PusherFake::Channel::Private, "#add" do
   end
 
   it "adds the connection to the channel when authorized" do
-    subject.stubs(authorized?: true)
+    allow(subject).to receive(:authorized?).and_return(true)
 
     subject.add(connection, data)
 
@@ -39,7 +39,7 @@ describe PusherFake::Channel::Private, "#add" do
   end
 
   it "successfully subscribes the connection when authorized" do
-    subject.stubs(authorized?: true)
+    allow(subject).to receive(:authorized?).and_return(true)
 
     subject.add(connection, data)
 
@@ -47,8 +47,8 @@ describe PusherFake::Channel::Private, "#add" do
   end
 
   it "triggers channel occupied webhook for the first connection added when authorized" do
-    subject.unstub(:connections)
-    subject.stubs(authorized?: true)
+    allow(subject).to receive(:authorized?).and_return(true)
+    allow(subject).to receive(:connections).and_call_original
 
     2.times { subject.add(connection, data) }
 
@@ -56,7 +56,7 @@ describe PusherFake::Channel::Private, "#add" do
   end
 
   it "unsuccessfully subscribes the connection when not authorized" do
-    subject.stubs(authorized?: false)
+    allow(subject).to receive(:authorized?).and_return(false)
 
     subject.add(connection, data)
 
@@ -64,34 +64,36 @@ describe PusherFake::Channel::Private, "#add" do
   end
 
   it "does not trigger channel occupied webhook when not authorized" do
-    subject.unstub(:connections)
-    subject.stubs(authorized?: false)
+    allow(subject).to receive(:authorized?).and_return(false)
+    allow(subject).to receive(:connections).and_call_original
 
     2.times { subject.add(connection, data) }
 
-    expect(PusherFake::Webhook).to have_received(:trigger).never
+    expect(PusherFake::Webhook).to_not have_received(:trigger)
   end
 end
 
 describe PusherFake::Channel::Private, "#authentication_for" do
   let(:id)            { "1234" }
   let(:name)          { "private-channel" }
+  let(:digest)        { double(:digest) }
   let(:string)        { [id, name].join(":") }
   let(:signature)     { "signature" }
-  let(:configuration) { stub(key: "key", secret: "secret") }
+  let(:configuration) { double(:configuration, key: "key", secret: "secret") }
 
   subject { PusherFake::Channel::Private.new(name) }
 
   before do
-    PusherFake.stubs(configuration: configuration)
-    OpenSSL::HMAC.stubs(hexdigest: signature)
+    allow(PusherFake).to receive(:configuration).and_return(configuration)
+    allow(OpenSSL::HMAC).to receive(:hexdigest).and_return(signature)
+    allow(OpenSSL::Digest::SHA256).to receive(:new).and_return(digest)
   end
 
   it "generates a signature" do
     subject.authentication_for(id)
 
     expect(OpenSSL::HMAC).to have_received(:hexdigest)
-      .with(kind_of(OpenSSL::Digest::SHA256), configuration.secret, string)
+      .with(digest, configuration.secret, string)
   end
 
   it "returns the authentication string" do
@@ -104,23 +106,25 @@ end
 describe PusherFake::Channel::Private, "#authentication_for, with channel data" do
   let(:id)            { "1234" }
   let(:name)          { "private-channel" }
+  let(:digest)        { double(:digest) }
   let(:string)        { [id, name, channel_data].join(":") }
   let(:signature)     { "signature" }
   let(:channel_data)  { "{}" }
-  let(:configuration) { stub(key: "key", secret: "secret") }
+  let(:configuration) { double(:configuration, key: "key", secret: "secret") }
 
   subject { PusherFake::Channel::Private.new(name) }
 
   before do
-    PusherFake.stubs(configuration: configuration)
-    OpenSSL::HMAC.stubs(hexdigest: signature)
+    allow(PusherFake).to receive(:configuration).and_return(configuration)
+    allow(OpenSSL::HMAC).to receive(:hexdigest).and_return(signature)
+    allow(OpenSSL::Digest::SHA256).to receive(:new).and_return(digest)
   end
 
   it "generates a signature" do
     subject.authentication_for(id, channel_data)
 
     expect(OpenSSL::HMAC).to have_received(:hexdigest)
-      .with(kind_of(OpenSSL::Digest::SHA256), configuration.secret, string)
+      .with(digest, configuration.secret, string)
   end
 
   it "returns the authentication string" do
@@ -133,14 +137,14 @@ end
 describe PusherFake::Channel::Private, "#authorized?" do
   let(:data)           { { auth: authentication, channel_data: channel_data } }
   let(:name)           { "private-channel" }
-  let(:connection)     { stub(id: "1") }
+  let(:connection)     { double(:connection, id: "1") }
   let(:channel_data)   { "{}" }
   let(:authentication) { "authentication" }
 
   subject { PusherFake::Channel::Private.new(name) }
 
   before do
-    subject.stubs(:authentication_for)
+    allow(subject).to receive(:authentication_for)
   end
 
   it "generates authentication for the connection ID" do
@@ -150,13 +154,13 @@ describe PusherFake::Channel::Private, "#authorized?" do
   end
 
   it "returns true if the authentication matches" do
-    subject.stubs(authentication_for: authentication)
+    allow(subject).to receive(:authentication_for).and_return(authentication)
 
     expect(subject).to be_authorized(connection, data)
   end
 
   it "returns false if the authentication matches" do
-    subject.stubs(authentication_for: "")
+    allow(subject).to receive(:authentication_for).and_return("")
 
     expect(subject).to_not be_authorized(connection, data)
   end

data/spec/lib/pusher-fake/channel/public_spec.rb

@@ -20,14 +20,14 @@ end
 
 describe PusherFake::Channel, "#add" do
   let(:name)        { "name" }
-  let(:connection)  { stub(emit: nil) }
-  let(:connections) { stub(push: nil, length: 0) }
+  let(:connection)  { double(:connection, emit: nil) }
+  let(:connections) { double(:connections, push: nil, length: 0) }
 
   subject { PusherFake::Channel::Public.new(name) }
 
   before do
-    PusherFake::Webhook.stubs(:trigger)
-    subject.stubs(connections: connections)
+    allow(PusherFake::Webhook).to receive(:trigger)
+    allow(subject).to receive(:connections).and_return(connections)
   end
 
   it "adds the connection" do
@@ -43,7 +43,7 @@ describe PusherFake::Channel, "#add" do
   end
 
   it "triggers channel occupied webhook for the first connection added" do
-    subject.unstub(:connections)
+    allow(subject).to receive(:connections).and_call_original
 
     2.times { subject.add(connection) }
 
@@ -52,17 +52,17 @@ describe PusherFake::Channel, "#add" do
 end
 
 describe PusherFake::Channel, "#emit" do
-  let(:data)         { stub }
+  let(:data)         { double }
   let(:name)         { "name" }
   let(:event)        { "event" }
   let(:connections)  { [connection_1, connection_2] }
-  let(:connection_1) { stub(emit: nil, id: "1") }
-  let(:connection_2) { stub(emit: nil, id: "2") }
+  let(:connection_1) { double(:connection, emit: nil, id: "1") }
+  let(:connection_2) { double(:connection, emit: nil, id: "2") }
 
   subject { PusherFake::Channel::Public.new(name) }
 
   before do
-    subject.stubs(connections: connections)
+    allow(subject).to receive(:connections).and_return(connections)
   end
 
   it "emits the event for each connection in the channel" do
@@ -76,23 +76,23 @@ describe PusherFake::Channel, "#emit" do
     subject.emit(event, data, socket_id: connection_2.id)
 
     expect(connection_1).to have_received(:emit).with(event, data, name)
-    expect(connection_2).to have_received(:emit).never
+    expect(connection_2).to_not have_received(:emit)
   end
 end
 
 describe PusherFake::Channel, "#includes?" do
-  let(:connection) { stub }
+  let(:connection) { double }
 
   subject { PusherFake::Channel::Public.new("name") }
 
   it "returns true if the connection is in the channel" do
-    subject.stubs(connections: [connection])
+    allow(subject).to receive(:connections).and_return([connection])
 
     expect(subject).to be_includes(connection)
   end
 
   it "returns false if the connection is not in the channel" do
-    subject.stubs(connections: [])
+    allow(subject).to receive(:connections).and_return([])
 
     expect(subject).to_not be_includes(connection)
   end
@@ -100,14 +100,14 @@ end
 
 describe PusherFake::Channel, "#remove" do
   let(:name)         { "name" }
-  let(:connection_1) { stub  }
-  let(:connection_2) { stub }
+  let(:connection_1) { double  }
+  let(:connection_2) { double }
 
   subject { PusherFake::Channel::Public.new(name) }
 
   before do
-    subject.stubs(connections: [connection_1, connection_2])
-    PusherFake::Webhook.stubs(:trigger)
+    allow(subject).to receive(:connections).and_return([connection_1, connection_2])
+    allow(PusherFake::Webhook).to receive(:trigger)
   end
 
   it "removes the connection from the channel" do
@@ -119,7 +119,7 @@ describe PusherFake::Channel, "#remove" do
   it "triggers channel vacated webhook when all connections are removed" do
     subject.remove(connection_1)
 
-    expect(PusherFake::Webhook).to have_received(:trigger).never
+    expect(PusherFake::Webhook).to_not have_received(:trigger)
 
     subject.remove(connection_2)