pusher-fake 3.0.1 → 4.2.0

data/spec/features/client/subscribe_spec.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-feature "Client subscribing to a channel" do
-  before do
-    connect
-  end
-
-  scenario "successfully subscribes to a channel" do
-    subscribe_to("chat-message")
-
-    expect(page).to have_content("Subscribed to chat-message.")
-  end
-
-  scenario "successfully subscribes to multiple channel" do
-    subscribe_to("chat-enter")
-    subscribe_to("chat-exit")
-
-    expect(page).to have_content("Subscribed to chat-enter.")
-    expect(page).to have_content("Subscribed to chat-exit.")
-  end
-
-  scenario "successfully subscribes to a private channel" do
-    subscribe_to("private-message-bob")
-
-    expect(page).to have_content("Subscribed to private-message-bob.")
-  end
-
-  scenario "successfully subscribes to a presence channel" do
-    subscribe_to("presence-game-1")
-
-    expect(page).to have_content("Subscribed to presence-game-1.")
-  end
-
-  scenario "unsuccessfully subscribes to a private channel" do
-    override_socket_id("13.37")
-
-    attempt_to_subscribe_to("private-message-bob")
-
-    expect(page).not_to have_content("Subscribed to private-message-bob.")
-  end
-
-  scenario "unsuccessfully subscribes to a presence channel" do
-    override_socket_id("13.37")
-
-    attempt_to_subscribe_to("presence-game-1")
-
-    expect(page).not_to have_content("Subscribed to presence-game-1.")
-  end
-
-  protected
-
-  def attempt_to_subscribe_to(channel)
-    page.execute_script("Helpers.subscribe(#{MultiJson.dump(channel)})")
-  end
-
-  def connect
-    visit "/"
-
-    expect(page).to have_content("Client connected.")
-  end
-
-  def override_socket_id(value)
-    page.execute_script(
-      "Pusher.instance.connection.socket_id = #{MultiJson.dump(value)};"
-    )
-  end
-end

data/spec/features/server/event_spec.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-feature "Server triggers event" do
-  let(:event)           { "message" }
-  let(:other_user)      { "Bob" }
-  let(:public_channel)  { "chat" }
-  let(:private_channel) { "private-chat" }
-
-  before do
-    connect
-    connect_as(other_user)
-  end
-
-  scenario "on a subscribed public channel" do
-    subscribe_to(public_channel)
-    subscribe_to_as(public_channel, other_user)
-
-    trigger(public_channel, event)
-
-    expect(page).to have_event(event, on: public_channel)
-
-    using_session(other_user) do
-      expect(page).to have_event(event, on: public_channel)
-    end
-  end
-
-  scenario "on a previously subscribed public channel" do
-    subscribe_to(public_channel)
-    subscribe_to_as(public_channel, other_user)
-    unsubscribe_from(public_channel)
-
-    trigger(public_channel, event)
-
-    expect(page).not_to have_event(event, on: public_channel)
-
-    using_session(other_user) do
-      expect(page).to have_event(event, on: public_channel)
-    end
-  end
-
-  scenario "on an unsubscribed public channel" do
-    trigger(public_channel, event)
-
-    expect(page).not_to have_event(event, on: public_channel)
-
-    using_session(other_user) do
-      expect(page).not_to have_event(event, on: public_channel)
-    end
-  end
-
-  scenario "on a subscribed private channel" do
-    subscribe_to(private_channel)
-    subscribe_to_as(private_channel, other_user)
-
-    trigger(private_channel, event)
-
-    expect(page).to have_event(event, on: private_channel)
-
-    using_session(other_user) do
-      expect(page).to have_event(event, on: private_channel)
-    end
-  end
-
-  scenario "on a previously subscribed private channel" do
-    subscribe_to(private_channel)
-    subscribe_to_as(private_channel, other_user)
-    unsubscribe_from(private_channel)
-
-    trigger(private_channel, event)
-
-    expect(page).not_to have_event(event, on: private_channel)
-
-    using_session(other_user) do
-      expect(page).to have_event(event, on: private_channel)
-    end
-  end
-
-  scenario "on an unsubscribed private channel" do
-    trigger(private_channel, event)
-
-    expect(page).not_to have_event(event, on: private_channel)
-
-    using_session(other_user) do
-      expect(page).not_to have_event(event, on: private_channel)
-    end
-  end
-
-  scenario "on multiple subscribed private channels" do
-    subscribe_to("private-chat-1")
-    subscribe_to_as("private-chat-2", other_user)
-
-    trigger("private-chat-1", event)
-    trigger("private-chat-2", event)
-
-    expect(page).to have_event(event, on: "private-chat-1")
-
-    using_session(other_user) do
-      expect(page).to have_event(event, on: "private-chat-2")
-    end
-  end
-
-  scenario "on a subscribed public channel, ignoring a user" do
-    subscribe_to(public_channel)
-    subscribe_to_as(public_channel, other_user)
-
-    trigger(public_channel, event, socket_id: user_id(other_user))
-
-    expect(page).to have_event(event, on: public_channel)
-
-    using_session(other_user) do
-      expect(page).not_to have_event(event, on: public_channel)
-    end
-  end
-
-  protected
-
-  def trigger(channel, event, options = {})
-    Pusher.trigger(channel, event, {}, options)
-  end
-end

data/spec/features/server/webhooks_spec.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-feature "Receiving event webhooks" do
-  let(:channel)          { "room-1" }
-  let(:other_user)       { "Bob" }
-  let(:presence_channel) { "presence-room-1" }
-
-  before do
-    events.clear
-
-    PusherFake.configuration.webhooks = ["http://127.0.0.1:8082"]
-
-    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 events
-    sleep(1)
-
-    WebhookHelper.mutex.synchronize do
-      WebhookHelper.events
-    end
-  end
-
-  def include_event(event, options = {})
-    include(options.merge("name" => event))
-  end
-end

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

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe PusherFake::Channel::Presence do
-  subject { described_class }
-
-  let(:name) { "channel" }
-
-  it "inherits from private channel" do
-    expect(subject.ancestors).to include(PusherFake::Channel::Private)
-  end
-
-  it "creates an empty members hash" do
-    channel = subject.new(name)
-
-    expect(channel.members).to eq({})
-  end
-end
-
-describe PusherFake::Channel::Presence, "#add" do
-  subject { described_class.new(name) }
-
-  let(:name)              { "name" }
-  let(:user_id)           { "1234" }
-  let(:connection)        { instance_double(PusherFake::Connection, emit: nil) }
-  let(:connections)       { instance_double(Array, push: nil, length: 0) }
-  let(:channel_data)      { { user_id: user_id } }
-  let(:authentication)    { "auth" }
-  let(:subscription_data) { { presence: { hash: {}, count: 1 } } }
-
-  let(:data) do
-    { auth:         authentication,
-      channel_data: MultiJson.dump(channel_data) }
-  end
-
-  before do
-    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
-    allow(subject).to receive(:authorized?).and_return(nil)
-
-    subject.add(connection, data)
-
-    expect(subject).to have_received(:authorized?).with(connection, data)
-  end
-
-  it "parses the channel_data when authorized" do
-    allow(subject).to receive(:authorized?).and_return(true)
-
-    subject.add(connection, data)
-
-    expect(MultiJson).to have_received(:load)
-      .with(data[:channel_data], symbolize_keys: true)
-  end
-
-  it "assigns the channel_data to the members hash for current connection" do
-    allow(subject).to receive(:authorized?).and_return(true)
-
-    subject.add(connection, data)
-
-    expect(subject.members[connection]).to eq(channel_data)
-  end
-
-  it "notifies the channel of the new member when authorized" do
-    allow(subject).to receive(:authorized?).and_return(true)
-
-    subject.add(connection, data)
-
-    expect(subject).to have_received(:emit)
-      .with("pusher_internal:member_added", channel_data)
-  end
-
-  it "successfully subscribes the connection when authorized" do
-    allow(subject).to receive(:authorized?).and_return(true)
-
-    subject.add(connection, data)
-
-    expect(connection).to have_received(:emit)
-      .with("pusher_internal:subscription_succeeded",
-            subscription_data, subject.name)
-  end
-
-  it "adds the connection to the channel when authorized" do
-    allow(subject).to receive(:authorized?).and_return(true)
-
-    subject.add(connection, data)
-
-    expect(connections).to have_received(:push).with(connection)
-  end
-
-  it "triggers occupied webhook for first connection added when authorized" do
-    allow(subject).to receive(:authorized?).and_return(true)
-    allow(subject).to receive(:connections).and_call_original
-
-    2.times { subject.add(connection, data) }
-
-    expect(PusherFake::Webhook).to have_received(:trigger)
-      .with("channel_occupied", channel: name).once
-  end
-
-  it "triggers the member added webhook when authorized" do
-    allow(subject).to receive(:authorized?).and_return(true)
-
-    subject.add(connection, data)
-
-    expect(PusherFake::Webhook).to have_received(:trigger)
-      .with("member_added", channel: name, user_id: user_id).once
-  end
-
-  it "unsuccessfully subscribes the connection when not authorized" do
-    allow(subject).to receive(:authorized?).and_return(false)
-
-    subject.add(connection, data)
-
-    expect(connection).to have_received(:emit)
-      .with("pusher_internal:subscription_error", {}, subject.name)
-  end
-
-  it "does not trigger channel occupied webhook when not authorized" do
-    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).not_to have_received(:trigger)
-  end
-
-  it "does not trigger the member added webhook when not authorized" do
-    allow(subject).to receive(:authorized?).and_return(false)
-
-    subject.add(connection, data)
-
-    expect(PusherFake::Webhook).not_to have_received(:trigger)
-  end
-end
-
-describe PusherFake::Channel::Presence, "#remove" do
-  subject { described_class.new(name) }
-
-  let(:name)         { "name" }
-  let(:user_id)      { "1234" }
-  let(:connection)   { double }
-  let(:channel_data) { { user_id: user_id } }
-
-  before do
-    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
-  end
-
-  it "removes the connection from the channel" do
-    subject.remove(connection)
-
-    expect(subject.connections).to be_empty
-  end
-
-  it "removes the connection from the members hash" do
-    subject.remove(connection)
-
-    expect(subject.members).not_to have_key(connection)
-  end
-
-  it "triggers the member removed webhook" do
-    subject.remove(connection)
-
-    expect(PusherFake::Webhook).to have_received(:trigger)
-      .with("member_removed", channel: name, user_id: user_id).once
-  end
-
-  it "notifies the channel of the removed member" do
-    subject.remove(connection)
-
-    expect(subject).to have_received(:emit)
-      .with("pusher_internal:member_removed", channel_data)
-  end
-end
-
-describe PusherFake::Channel::Presence,
-         "#remove, for an unsubscribed connection" do
-  subject { described_class.new(name) }
-
-  let(:name)         { "name" }
-  let(:user_id)      { "1234" }
-  let(:connection)   { double }
-  let(:channel_data) { { user_id: user_id } }
-
-  before do
-    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
-    expect do
-      subject.remove(connection)
-    end.not_to raise_error
-  end
-
-  it "does not trigger an event" do
-    subject.remove(connection)
-
-    expect(subject).not_to 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).not_to have_received(:emit)
-      .with("pusher_internal:member_removed", channel_data)
-  end
-end
-
-describe PusherFake::Channel::Presence, "#subscription_data" do
-  subject { described_class.new("name") }
-
-  let(:one)     { { user_id: 1, name: "Bob" } }
-  let(:two)     { { user_id: 2, name: "Beau" } }
-  let(:data)    { subject.subscription_data }
-  let(:members) { { double => one } }
-
-  before do
-    allow(subject).to receive(:members).and_return(members)
-  end
-
-  it "returns hash with presence information" do
-    expect(data).to eq(presence: {
-                         hash:  { one[:user_id] => one[:user_info] },
-                         count: 1
-                       })
-  end
-
-  it "handles multiple members" do
-    members[double] = two
-
-    expect(data[:presence][:count]).to eq(2)
-    expect(data[:presence][:hash]).to eq(
-      one[:user_id] => one[:user_info], two[:user_id] => two[:user_info]
-    )
-  end
-end

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

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe PusherFake::Channel::Private do
-  subject { described_class }
-
-  it "inherits from public channel" do
-    expect(subject.ancestors).to include(PusherFake::Channel::Public)
-  end
-end
-
-describe PusherFake::Channel::Private, "#add" do
-  subject { described_class.new(name) }
-
-  let(:data)           { { auth: authentication } }
-  let(:name)           { "name" }
-  let(:connection)     { instance_double(PusherFake::Connection, emit: nil) }
-  let(:connections)    { instance_double(Array, push: nil, length: 0) }
-  let(:authentication) { "auth" }
-
-  before do
-    allow(PusherFake::Webhook).to receive(:trigger)
-    allow(subject).to receive(:connections).and_return(connections)
-  end
-
-  it "authorizes the connection" do
-    allow(subject).to receive(:authorized?).and_return(nil)
-
-    subject.add(connection, data)
-
-    expect(subject).to have_received(:authorized?).with(connection, data)
-  end
-
-  it "adds the connection to the channel when authorized" do
-    allow(subject).to receive(:authorized?).and_return(true)
-
-    subject.add(connection, data)
-
-    expect(connections).to have_received(:push).with(connection)
-  end
-
-  it "successfully subscribes the connection when authorized" do
-    allow(subject).to receive(:authorized?).and_return(true)
-
-    subject.add(connection, data)
-
-    expect(connection).to have_received(:emit)
-      .with("pusher_internal:subscription_succeeded", {}, subject.name)
-  end
-
-  it "triggers occupied webhook for first connection added when authorized" do
-    allow(subject).to receive(:authorized?).and_return(true)
-    allow(subject).to receive(:connections).and_call_original
-
-    2.times { subject.add(connection, data) }
-
-    expect(PusherFake::Webhook).to have_received(:trigger)
-      .with("channel_occupied", channel: name).once
-  end
-
-  it "unsuccessfully subscribes the connection when not authorized" do
-    allow(subject).to receive(:authorized?).and_return(false)
-
-    subject.add(connection, data)
-
-    expect(connection).to have_received(:emit)
-      .with("pusher_internal:subscription_error", {}, subject.name)
-  end
-
-  it "does not trigger channel occupied webhook when not authorized" do
-    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).not_to have_received(:trigger)
-  end
-end
-
-describe PusherFake::Channel::Private, "#authentication_for" do
-  subject { described_class.new(name) }
-
-  let(:id)        { "1234" }
-  let(:name)      { "private-channel" }
-  let(:digest)    { instance_double(OpenSSL::Digest::SHA256) }
-  let(:string)    { [id, name].join(":") }
-  let(:signature) { "signature" }
-
-  let(:configuration) do
-    instance_double(PusherFake::Configuration, key: "key", secret: "secret")
-  end
-
-  before do
-    allow(PusherFake).to receive(:configuration).and_return(configuration)
-    allow(OpenSSL::HMAC).to receive(:hexdigest).and_return(signature)
-    allow(OpenSSL::Digest).to receive(:new).with("SHA256").and_return(digest)
-  end
-
-  it "generates a signature" do
-    subject.authentication_for(id)
-
-    expect(OpenSSL::HMAC).to have_received(:hexdigest)
-      .with(digest, configuration.secret, string)
-  end
-
-  it "returns the authentication string" do
-    string = subject.authentication_for(id)
-
-    expect(string).to eq("#{configuration.key}:#{signature}")
-  end
-end
-
-describe PusherFake::Channel::Private,
-         "#authentication_for, with channel data" do
-  subject { described_class.new(name) }
-
-  let(:id)           { "1234" }
-  let(:name)         { "private-channel" }
-  let(:digest)       { instance_double(OpenSSL::Digest::SHA256) }
-  let(:string)       { [id, name, channel_data].join(":") }
-  let(:signature)    { "signature" }
-  let(:channel_data) { "{}" }
-
-  let(:configuration) do
-    instance_double(PusherFake::Configuration, key: "key", secret: "secret")
-  end
-
-  before do
-    allow(PusherFake).to receive(:configuration).and_return(configuration)
-    allow(OpenSSL::HMAC).to receive(:hexdigest).and_return(signature)
-    allow(OpenSSL::Digest).to receive(:new).with("SHA256").and_return(digest)
-  end
-
-  it "generates a signature" do
-    subject.authentication_for(id, channel_data)
-
-    expect(OpenSSL::HMAC).to have_received(:hexdigest)
-      .with(digest, configuration.secret, string)
-  end
-
-  it "returns the authentication string" do
-    string = subject.authentication_for(id, channel_data)
-
-    expect(string).to eq("#{configuration.key}:#{signature}")
-  end
-end
-
-describe PusherFake::Channel::Private, "#authorized?" do
-  subject { described_class.new(name) }
-
-  let(:data)           { { auth: authentication, channel_data: channel_data } }
-  let(:name)           { "private-channel" }
-  let(:connection)     { instance_double(PusherFake::Connection, id: "1") }
-  let(:channel_data)   { "{}" }
-  let(:authentication) { "authentication" }
-
-  before do
-    allow(subject).to receive(:authentication_for)
-  end
-
-  it "generates authentication for the connection ID" do
-    subject.authorized?(connection, data)
-
-    expect(subject).to have_received(:authentication_for)
-      .with(connection.id, channel_data)
-  end
-
-  it "returns true if the authentication matches" do
-    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
-    allow(subject).to receive(:authentication_for).and_return("")
-
-    expect(subject).not_to be_authorized(connection, data)
-  end
-end