pusher-fake 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c3f79253d72f830d37f4a25a95b9bde1d58cdb19
-  data.tar.gz: fa1401d5a24e2d49f2ed0b89cd02b663e5dd0361
+  metadata.gz: e6cba6ba2781f922d0e29bcb41add3f6a3a03595
+  data.tar.gz: 30198ebca214e71b377562aec841ce4aa80ee71d
 SHA512:
-  metadata.gz: 4b629399e6094408686c54492d02e40a19a5331f85057a97146fe879e88d6f3f44812e0d334dd759bd33051a0495c55cecae80ae150710ffe0d30516f0e56425
-  data.tar.gz: e9a65e650f03408fe170c9d88fac0cfa05b8061ade712812304ddabe270c9853fedf63a3a960ac879e2cae5dd41f530a8487ca6c828147fc09dc49fe0696de1c
+  metadata.gz: 75903dbd7cd960d3d762934dea6395dbfd9cfb8e4b201cf7c989e58ee58f9bf98a691371f5922286a2994dc63141e6261ad1dab4615ed75f59c9e5e7c1f9b219
+  data.tar.gz: 3f9628b6a3ec64220c88fd48afb487c83e5191c8a1643a2ca97b6200f6071aa7f90f1507abeea48c43b2d71aa1ccf5e8add5cb1ba9e9483a6b3d127d8f22e47f

data/lib/pusher-fake.rb

@@ -6,7 +6,7 @@ require "thin"
 
 module PusherFake
   # The current version string.
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 
   autoload :Channel,       "pusher-fake/channel"
   autoload :Configuration, "pusher-fake/configuration"

data/lib/pusher-fake/configuration.rb

@@ -47,7 +47,8 @@ module PusherFake
     def to_options(options = {})
       options.merge(
         wsHost: socket_options[:host],
-        wsPort: socket_options[:port]
+        wsPort: socket_options[:port],
+        enabledTransports: ["ws"]
       )
     end
 

data/lib/pusher-fake/server/application.rb

@@ -59,7 +59,7 @@ module PusherFake
       # presence channels.
       #
       # @param [String] name The channel name.
-      # @params [Rack::Request] request The HTTP request.
+      # @param [Rack::Request] request The HTTP request.
       # @return [Hash] A hash of channel information.
       def self.channel(name, request)
         info = request.params["info"].to_s.split(",")

data/spec/features/api/channels_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+feature "Requesting channel API endpoint" do
+  let(:channel_name)  { "public-1" }
+  let(:presence_name) { "presence-example" }
+
+  before do
+    connect
+  end
+
+  scenario "all channels, with none created" do
+    expect(channels).to be_empty
+  end
+
+  scenario "all channels, with one created" do
+    subscribe_to(channel_name)
+
+    expect(channels).to have_key(channel_name)
+  end
+
+  scenario "all channels, with a filter" do
+    subscribe_to("other")
+    subscribe_to(channel_name)
+
+    result = channels(filter_by_prefix: "pu")
+
+    expect(result.size).to eq(1)
+    expect(result).to have_key(channel_name)
+  end
+
+  scenario "all channels, with info attributes" do
+    subscribe_to(presence_name)
+
+    result = channels(filter_by_prefix: "presence-", info: "user_count")
+
+    expect(result.size).to eq(1)
+    expect(result).to have_key(presence_name)
+    expect(result[presence_name]).to have_key("user_count")
+    expect(result[presence_name]["user_count"]).to eq(1)
+  end
+
+ scenario "all channels, with invalid info attributes" do
+    expect {
+      channels(info: "user_count")
+    }.to raise_error(/user_count may only be requested for presence channels/)
+  end
+
+  scenario "channel, with no occupants" do
+    expect(channel[:occupied]).to eq(false)
+  end
+
+  scenario "channel, with an occupant" do
+    subscribe_to(channel_name)
+
+    expect(channel[:occupied]).to eq(true)
+  end
+
+  scenario "channel, with info attributes" do
+    subscribe_to(presence_name)
+
+    result = Pusher.get("/channels/#{presence_name}", info: "user_count")
+
+    expect(result[:occupied]).to eq(true)
+    expect(result[:user_count]).to eq(1)
+  end
+
+  scenario "channel, with invalid info attributes" do
+    expect {
+      channel(info: "user_count")
+    }.to raise_error(/Cannot retrieve the user count unless the channel is a presence channel/)
+  end
+
+  protected
+
+  def channel(options = {})
+    Pusher.get("/channels/#{channel_name}", options)
+  end
+
+  def channels(options = {})
+    Pusher.get("/channels", options)[:channels]
+  end
+end

data/spec/features/api/users_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+feature "Requesting user API endpoint" do
+  let(:users)   { Pusher.get("/channels/#{channel_name}/users")[:users] }
+  let(:channel_name) { "public-1" }
+
+  before do
+    connect
+    connect_as "Bob"
+  end
+
+  scenario "with no users subscribed" do
+    expect(users).to be_empty
+  end
+
+  scenario "with a single user subscribed" do
+    subscribe_to(channel_name)
+
+    expect(users.size).to eq(1)
+  end
+
+  scenario "with a multiple users subscribed" do
+    subscribe_to(channel_name)
+    subscribe_to_as(channel_name, "Bob")
+
+    ids = PusherFake::Channel.channels[channel_name].connections.map(&:id)
+
+    expect(users.size).to eq(2)
+
+    users.each do |user|
+      expect(ids).to include(user["id"])
+    end
+  end
+end

data/spec/features/client/connect_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+feature "Client connecting to the server" do
+  scenario "successfully connects" do
+    visit "/"
+
+    expect(page).to have_content("Client connected.")
+  end
+end

data/spec/features/client/event_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+feature "Client triggers a client event" do
+  let(:event)           { "client-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 private channel" do
+    subscribe_to(private_channel)
+    subscribe_to_as(private_channel, other_user)
+
+    trigger(private_channel, event)
+
+    expect(page).to_not 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 subscribed public channel" do
+    subscribe_to(public_channel)
+    subscribe_to_as(public_channel, other_user)
+
+    trigger(public_channel, event)
+
+    expect(page).to_not have_event(event, on: public_channel)
+
+    using_session(other_user) do
+      expect(page).to_not have_event(event, on: public_channel)
+    end
+  end
+
+  protected
+
+  def trigger(channel, event)
+    page.execute_script("Helpers.trigger(#{MultiJson.dump(channel)}, #{MultiJson.dump(event)})")
+  end
+end

data/spec/features/client/presence_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+feature "Client on a presence channel" do
+  let(:other_user) { "Bob" }
+
+  before do
+    connect
+  end
+
+  scenario "subscribing to a presence channel" do
+    subscribe_to("presence-game-1")
+
+    expect(page).to have_clients(1, in: "presence-game-1")
+  end
+
+  scenario "subscribing to a presence channel, with existing users" do
+    connect_as(other_user, channel: "presence-game-1")
+
+    subscribe_to("presence-game-1")
+
+    expect(page).to have_clients(2, in: "presence-game-1", named: "Alan Turing")
+  end
+
+  scenario "member entering notification" do
+    subscribe_to("presence-game-1")
+
+    connect_as(other_user, channel: "presence-game-1")
+
+    expect(page).to have_clients(2, in: "presence-game-1")
+  end
+
+  scenario "member leaving notification" do
+    connect_as(other_user, channel: "presence-game-1")
+    subscribe_to("presence-game-1")
+
+    expect(page).to have_clients(2, in: "presence-game-1")
+
+    unsubscribe_from_as("presence-game-1", other_user)
+
+    expect(page).to have_clients(1, in: "presence-game-1")
+  end
+
+  scenario "other client connecting" do
+    subscribe_to("presence-game-1")
+
+    connect_as(other_user)
+
+    expect(page).to have_clients(1, in: "presence-game-1")
+  end
+
+  protected
+
+  def have_clients(count, options = {})
+    have_css("li.channel-#{options[:in]}", count: count, text: options[:named])
+  end
+end

data/spec/features/client/subscribe_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+feature "Client subscribing to a channel" do
+  before do
+    visit "/"
+
+    expect(page).to have_content("Client connected.")
+  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
+    set_socket_id(-1)
+
+    attempt_to_subscribe_to("private-message-bob")
+
+    expect(page).to_not have_content("Subscribed to private-message-bob.")
+  end
+
+  scenario "unsuccessfully subscribes to a presence channel" do
+    set_socket_id(-1)
+
+    attempt_to_subscribe_to("presence-game-1")
+
+    expect(page).to_not 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 set_socket_id(value)
+    page.execute_script("Pusher.instance.connection.socket_id = #{MultiJson.dump(value)};")
+  end
+end

data/spec/features/server/event_spec.rb

@@ -0,0 +1,120 @@
+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).to_not 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).to_not have_event(event, on: public_channel)
+
+    using_session(other_user) do
+      expect(page).to_not 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).to_not 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).to_not have_event(event, on: private_channel)
+
+    using_session(other_user) do
+      expect(page).to_not 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).to_not have_event(event, on: public_channel)
+    end
+  end
+
+  protected
+
+  def trigger(channel, event, options = {})
+    Pusher.trigger(channel, event, {}, options)
+  end
+end