pusher-fake 0.4.0 → 0.5.0

data/features/channel.feature

@@ -0,0 +1,109 @@
+@javascript
+Feature: Requesting channel information
+
+  Background:
+    Given I am connected
+
+  Scenario: Requesting all channels
+    When I request "/channels"
+    Then I should receive the following JSON:
+      """
+        { "channels" : {} }
+      """
+    When I subscribe to the "chat-message" channel
+    And I request "/channels"
+    Then I should receive the following JSON:
+      """
+        { "channels" : {
+            "chat-message" : {}
+          }
+        }
+      """
+    When I subscribe to the "presence-game-1" channel with presence events
+    And I request "/channels"
+    Then I should receive the following JSON:
+      """
+        { "channels" : {
+            "chat-message"    : {},
+            "presence-game-1" : {}
+          }
+        }
+      """
+
+  Scenario: Requesting all channels, with a filter
+    Given I subscribe to the "chat-message" channel
+    And I subscribe to the "presence-game-1" channel with presence events
+    When I request "/channels" with the following options:
+      | filter_by_prefix |
+      | chat             |
+    Then I should receive the following JSON:
+      """
+        { "channels" : {
+            "chat-message" : {}
+          }
+        }
+      """
+
+  Scenario: Requesting all channels, with a valid filter and info attributes
+    Given I subscribe to the "chat-message" channel
+    And I subscribe to the "presence-game-1" channel with presence events
+    When I request "/channels" with the following options:
+      | filter_by_prefix | info       |
+      | presence-        | user_count |
+    Then I should receive the following JSON:
+      """
+        { "channels" : {
+            "presence-game-1" : {
+              "user_count" : 1
+            }
+          }
+        }
+      """
+
+  Scenario: Requesting all channels, with an invalid filter and info attributes
+    Given I subscribe to the "chat-message" channel
+    And I subscribe to the "presence-game-1" channel with presence events
+    When I request "/channels" with the following options:
+      | filter_by_prefix | info       |
+      | chat-            | user_count |
+    Then I should receive the following error:
+      """
+        user_count may only be requested for presence channels - please supply filter_by_prefix begining with presence-
+      """
+
+  Scenario: Requesting a channel, with no occupants
+    When I request "/channels/empty"
+    Then I should receive the following JSON:
+    """
+      { "occupied" : false }
+    """
+
+  Scenario: Requesting a channel, with an occupant
+    Given I subscribe to the "non-empty" channel
+    When I request "/channels/non-empty"
+    Then I should receive the following JSON:
+    """
+      { "occupied" : true }
+    """
+
+  Scenario: Requesting a channel, with valid info attributes
+    Given I subscribe to the "presence-1" channel
+    And Bob is connected
+    And Bob is subscribed to the "presence-1" channel
+    When I request "/channels/presence-1" with the following options:
+      | info       |
+      | user_count |
+    Then I should receive the following JSON:
+    """
+      { "occupied"   : true,
+        "user_count" : 2 }
+    """
+
+  Scenario: Requesting a channel, with invalid info attributes
+    When I request "/channels/public-1" with the following options:
+      | info       |
+      | user_count |
+    Then I should receive the following error:
+      """
+        Cannot retrieve the user count unless the channel is a presence channel
+      """

data/features/step_definitions/api_steps.rb

@@ -0,0 +1,38 @@
+When %{I request "$path"} do |path|
+  wait do
+    @response = Pusher.get(path)
+  end
+end
+
+When %{I request "$path" with the following options:} do |path, table|
+  wait do
+    begin
+      @response = Pusher.get(path, table.hashes.first)
+    rescue => error
+      @error = error
+    end
+  end
+end
+
+Then %{I should receive the following JSON:} do |string|
+  expected = MultiJson.load(string)
+  expected = expected.inject({}) do |result, (key, value)|
+    result[key.to_sym] = value
+    result
+  end
+
+  @response.should == expected
+end
+
+Then %{I should receive the following error:} do |string|
+  @error.message.should include(string.strip)
+end
+
+Then /^I should receive JSON for (\d+) users?$/ do |count|
+  users = @response[:users]
+  users.length.should == count.to_i
+  users.each do |user|
+    object = ObjectSpace._id2ref(user["id"])
+    object.should be_a(PusherFake::Connection)
+  end
+end

data/features/step_definitions/channel_steps.rb

@@ -61,7 +61,7 @@ When %{$name unsubscribes from the "$channel" channel} do |name, channel|
 end
 
 Then %{I should be subscribed to the "$channel" channel} do |channel|
-  Capybara.timeout do
+  timeout_after(5) do
     subscribed = page.evaluate_script(%{
       var
       channel = Pusher.instance.channel(#{MultiJson.dump(channel)});

data/features/step_definitions/client_steps.rb

@@ -14,14 +14,14 @@ Given "I change my socket ID" do
 end
 
 Then "I should be connected" do
-  Capybara.timeout do
+  timeout_after(5) do
     state = page.evaluate_script("Pusher.instance.connection.state")
     state == "connected"
   end
 end
 
 Then "I should not be connected" do
-  Capybara.timeout do
+  timeout_after(5) do
     state = page.evaluate_script("Pusher.instance.connection.state")
     state == "unavailable"
   end

data/features/step_definitions/webhook_steps.rb

@@ -7,7 +7,7 @@ Then /^the server should have received the following (user )*event:$/ do |user_e
     end
   end if user_event
 
-  Capybara.timeout do
+  timeout_after(5) do
     $events.include?(event)
   end
 

data/features/support/timing.rb

@@ -0,0 +1,15 @@
+module Capybara
+  module Timing
+    def wait(seconds = 0.25, &block)
+      sleep(seconds) && yield
+    end
+
+    def timeout_after(seconds, &block)
+      Timeout::timeout(seconds) do
+        sleep(0.05) until yield
+      end
+    end
+  end
+end
+
+World(Capybara::Timing)

data/features/support/webhooks.rb

@@ -28,8 +28,8 @@ end.tap do |thread|
   at_exit { thread.exit }
 
   # Wait for the webhook endpoint server to start.
-  Capybara.timeout do
-    thread[:ready]
+  Timeout::timeout(5) do
+    sleep(0.05) until thread[:ready]
   end
 end
 

data/features/user.feature

@@ -0,0 +1,14 @@
+@javascript
+Feature: Requesting user information
+
+  Scenario: Requesting users for a channel
+    Given I am connected
+    And Bob is connected
+    When I request "/channels/public-1/users"
+    Then I should receive JSON for 0 users
+    When I subscribe to the "public-1" channel
+    And I request "/channels/public-1/users"
+    Then I should receive JSON for 1 user
+    When Bob is subscribed to the "public-1" channel
+    And I request "/channels/public-1/users"
+    Then I should receive JSON for 2 users

data/lib/pusher-fake.rb

@@ -16,7 +16,7 @@ require "pusher-fake/webhook"
 
 module PusherFake
   # The current version string.
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 
   # Call this method to modify the defaults.
   #

data/lib/pusher-fake/channel.rb

@@ -2,10 +2,10 @@ module PusherFake
   module Channel
     class << self
       # Name matcher for private channels.
-      PRIVATE_CHANNEL_MATCHER  = /^private-/.freeze
+      PRIVATE_CHANNEL_MATCHER  = /\Aprivate-/.freeze
 
       # Name matcher for presence channels.
-      PRESENCE_CHANNEL_MATCHER = /^presence-/.freeze
+      PRESENCE_CHANNEL_MATCHER = /\Apresence-/.freeze
 
       # @return [Hash] Cache of existing channels.
       attr_accessor :channels
@@ -48,9 +48,10 @@ module PusherFake
       # @param [String] name The name of the channel.
       # @return [Class] The class to use for the channel.
       def class_for(name)
-        if name =~ PRIVATE_CHANNEL_MATCHER
+        case name
+        when PRIVATE_CHANNEL_MATCHER
           Private
-        elsif name =~ PRESENCE_CHANNEL_MATCHER
+        when PRESENCE_CHANNEL_MATCHER
           Presence
         else
           Public

data/lib/pusher-fake/channel/presence.rb

@@ -15,6 +15,8 @@ module PusherFake
 
       # Remove the +connection+ from the channel and notify the channel.
       #
+      # Also trigger the member_removed webhook.
+      #
       # @param [Connection] connection The connection to remove.
       def remove(connection)
         super
@@ -39,9 +41,11 @@ module PusherFake
 
       private
 
-      # Store the member data for the connection and notify connections a
+      # Store the member data for the connection and notify the channel a
       # member was added.
       #
+      # Also trigger the member_added webhook.
+      #
       # @param [Connection] connection The connection a subscription succeeded for.
       # @param [Hash] options The options for the channel.
       def subscription_succeeded(connection, options = {})

data/lib/pusher-fake/channel/public.rb

@@ -45,6 +45,8 @@ module PusherFake
 
       # Remove the +connection+ from the channel.
       #
+      # If it is the last connection, trigger the channel_vacated webhook.
+      #
       # @param [Connection] connection The connection to remove.
       def remove(connection)
         connections.delete(connection)
@@ -64,9 +66,11 @@ module PusherFake
 
       private
 
-      # Notify the channel of the successful subscription and add the
+      # Notify the +connection+ of the successful subscription and add the
       # connection to the channel.
       #
+      # If it is the first connection, trigger the channel_occupied webhook.
+      #
       # @param [Connection] connection The connection a subscription succeeded for.
       # @param [Hash] options The options for the channel.
       def subscription_succeeded(connection, options = {})

data/lib/pusher-fake/connection.rb

@@ -1,5 +1,8 @@
 module PusherFake
   class Connection
+    # Name matcher for client events.
+    CLIENT_EVENT_MATCHER  = /\Aclient-(.+)\Z/.freeze
+
     # @return [EventMachine::WebSocket::Connection] The socket object for this connection.
     attr_reader :socket
 
@@ -18,9 +21,8 @@ module PusherFake
     def emit(event, data = {}, channel = nil)
       message = { event: event, data: data }
       message[:channel] = channel if channel
-      message = MultiJson.dump(message)
 
-      socket.send(message)
+      socket.send(MultiJson.dump(message))
     end
 
     # Notify the Pusher client that a connection has been established.
@@ -43,7 +45,7 @@ module PusherFake
         channel.add(self, data)
       when "pusher:unsubscribe"
         channel.remove(self)
-      when /^client-(.+)$/
+      when CLIENT_EVENT_MATCHER
         return unless channel.is_a?(Channel::Private)
         return unless channel.includes?(self)
 

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

@@ -1,20 +1,115 @@
 module PusherFake
   module Server
     class Application
-      # Process an API request by emitting the event with data to the
-      # requested channels.
+      CHANNEL_FILTER_ERROR = "user_count may only be requested for presence channels - " +
+                               "please supply filter_by_prefix begining with presence-".freeze
+
+      CHANNEL_USER_COUNT_ERROR = "Cannot retrieve the user count unless the channel is a presence channel".freeze
+
+      PRESENCE_PREFIX_MATCHER = /\Apresence-/.freeze
+
+      # Process an API request.
       #
       # @param [Hash] environment The request environment.
       # @return [Rack::Response] A successful response.
       def self.call(environment)
-        request = Rack::Request.new(environment)
-        event   = MultiJson.load(request.body.read)
+        id       = PusherFake.configuration.app_id
+        request  = Rack::Request.new(environment)
+        response = case request.path
+                   when %r{\A/apps/#{id}/events\Z}
+                     events(request)
+                   when %r{\A/apps/#{id}/channels\Z}
+                     channels(request)
+                   when %r{\A/apps/#{id}/channels/([^/]+)\Z}
+                     channel($1, request)
+                   when %r{\A/apps/#{id}/channels/([^/]+)/users\Z}
+                     users($1)
+                   end
+
+        Rack::Response.new(MultiJson.dump(response)).finish
+      rescue => error
+        Rack::Response.new(error.message, 400).finish
+      end
 
+      # Emit an event with data to the requested channel(s).
+      #
+      # @param [Rack::Request] request The HTTP request.
+      # @return [Hash] An empty hash.
+      def self.events(request)
+        event = MultiJson.load(request.body.read)
         event["channels"].each do |channel|
           Channel.factory(channel).emit(event["name"], event["data"], socket_id: event["socket_id"])
         end
 
-        Rack::Response.new("{}").finish
+        {}
+      end
+
+      # Return a hash of channel information.
+      #
+      # Occupied status is always included. A user count may be requested for
+      # presence channels.
+      #
+      # @param [String] name The channel name.
+      # @params [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(",")
+
+        if info.include?("user_count") && name !~ PRESENCE_PREFIX_MATCHER
+          raise CHANNEL_USER_COUNT_ERROR
+        end
+
+        channels = PusherFake::Channel.channels || {}
+        channel  = channels[name]
+
+        {}.tap do |result|
+          result[:occupied]   = !channel.nil? && channel.connections.length > 0
+          result[:user_count] = channel.connections.length if channel && info.include?("user_count")
+        end
+      end
+
+      # Returns a hash of occupied channels, optionally filtering with a prefix.
+      #
+      # When filtering to presence chanenls, the user count maybe also be requested.
+      #
+      # @param [Rack::Request] request The HTTP request.
+      # @return [Hash] A hash of occupied channels.
+      def self.channels(request)
+        info   = request.params["info"].to_s.split(",")
+        prefix = request.params["filter_by_prefix"].to_s
+
+        if info.include?("user_count") && prefix !~ PRESENCE_PREFIX_MATCHER
+          raise CHANNEL_FILTER_ERROR
+        end
+
+        filter   = Regexp.new(%r{\A#{prefix}})
+        channels = PusherFake::Channel.channels || {}
+        channels.inject({ channels: {} }) do |result, (name, channel)|
+          unless filter && name !~ filter
+            channels = result[:channels]
+            channels[name] = {}
+            channels[name][:user_count] = channel.connections.length if info.include?("user_count")
+          end
+
+          result
+        end
+      end
+
+      # Returns a hash of the IDs for the users in the channel.
+      #
+      # @param [String] name The channel name.
+      # @return [Hash] A hash of user IDs.
+      def self.users(name)
+        channels = PusherFake::Channel.channels || {}
+        channel  = channels[name]
+
+        if channel
+          users = channel.connections.map do |connection|
+            { id: connection.object_id }
+          end
+        end
+
+        { users: users || [] }
       end
     end
   end

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

@@ -1,17 +1,10 @@
 require "spec_helper"
 
-describe PusherFake::Server::Application, ".call" do
-  let(:body)        { stub(read: json) }
-  let(:data)        { mock }
-  let(:json)        { mock }
-  let(:name)        { "event-name" }
-  let(:event)       { { "channels" => channels, "name" => name, "data" => data, "socket_id" => socket_id } }
-  let(:request)     { stub(body: body) }
-  let(:channels)    { ["channel-1", "channel-2"] }
+shared_examples_for "an API request" do
+  let(:hash)        { mock }
+  let(:string)      { mock }
+  let(:request)     { stub(path: path) }
   let(:response)    { mock }
-  let(:channel_1)   { stub(emit: true) }
-  let(:channel_2)   { stub(emit: true) }
-  let(:socket_id)   { stub }
   let(:environment) { mock }
 
   subject { PusherFake::Server::Application }
@@ -19,11 +12,9 @@ describe PusherFake::Server::Application, ".call" do
   before do
     response.stubs(finish: response)
 
-    MultiJson.stubs(load: event)
+    MultiJson.stubs(dump: string)
     Rack::Request.stubs(new: request)
     Rack::Response.stubs(new: response)
-    PusherFake::Channel.stubs(:factory).with(channels[0]).returns(channel_1)
-    PusherFake::Channel.stubs(:factory).with(channels[1]).returns(channel_2)
   end
 
   it "creates a request" do
@@ -31,28 +22,85 @@ describe PusherFake::Server::Application, ".call" do
     Rack::Request.should have_received(:new).with(environment)
   end
 
-  it "parses the request body as JSON" do
+  it "dumps the response hash to JSON" do
     subject.call(environment)
-    MultiJson.should have_received(:load).with(json)
+    MultiJson.should have_received(:dump).with(hash)
   end
 
-  it "creates channels by name" do
+  it "creates a Rack response with the response JSON" do
     subject.call(environment)
+    Rack::Response.should have_received(:new).with(string)
+  end
 
-    channels.each do |channel|
-      PusherFake::Channel.should have_received(:factory).with(channel)
+  it "finishes the response" do
+    subject.call(environment)
+    response.should have_received(:finish).with()
+  end
+
+  it "returns the response" do
+    subject.call(environment).should == response
+  end
+end
+
+describe PusherFake::Server::Application, ".call, for triggering events" do
+  it_should_behave_like "an API request" do
+    let(:id)   { PusherFake.configuration.app_id }
+    let(:path) { "/apps/#{id}/events" }
+
+    before do
+      subject.stubs(events: hash)
+    end
+
+    it "emits events" do
+      subject.call(environment)
+      subject.should have_received(:events).with(request)
     end
   end
+end
 
-  it "emits the event to the channels" do
+describe PusherFake::Server::Application, ".call, for retrieving occupied channels" do
+  it_should_behave_like "an API request" do
+    let(:id)   { PusherFake.configuration.app_id }
+    let(:path) { "/apps/#{id}/channels" }
+
+    before do
+      subject.stubs(channels: hash)
+    end
+
+    it "filters the occupied channels" do
+      subject.call(environment)
+      subject.should have_received(:channels).with(request)
+    end
+  end
+end
+
+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 }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    subject.stubs(:channels).raises(message)
+
+    response.stubs(finish: response)
+
+    Rack::Request.stubs(new: request)
+    Rack::Response.stubs(new: response)
+  end
+
+  it "creates a request" do
     subject.call(environment)
-    channel_1.should have_received(:emit).with(name, data, socket_id: socket_id)
-    channel_2.should have_received(:emit).with(name, data, socket_id: socket_id)
+    Rack::Request.should have_received(:new).with(environment)
   end
 
-  it "creates a Rack response with an empty JSON object" do
+  it "creates a Rack response with the error message" do
     subject.call(environment)
-    Rack::Response.should have_received(:new).with("{}")
+    Rack::Response.should have_received(:new).with(message, 400)
   end
 
   it "finishes the response" do
@@ -64,3 +112,256 @@ describe PusherFake::Server::Application, ".call" do
     subject.call(environment).should == response
   end
 end
+
+describe PusherFake::Server::Application, ".events" do
+  let(:body)      { stub(read: json) }
+  let(:data)      { mock }
+  let(:json)      { mock }
+  let(:name)      { "event-name" }
+  let(:event)     { { "channels" => channels, "name" => name, "data" => data, "socket_id" => socket_id } }
+  let(:request)   { stub(body: body) }
+  let(:channels)  { ["channel-1", "channel-2"] }
+  let(:channel_1) { stub(emit: true) }
+  let(:channel_2) { stub(emit: true) }
+  let(:socket_id) { stub }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    MultiJson.stubs(load: event)
+    PusherFake::Channel.stubs(:factory).with(channels[0]).returns(channel_1)
+    PusherFake::Channel.stubs(:factory).with(channels[1]).returns(channel_2)
+  end
+
+  it "parses the request body as JSON" do
+    subject.events(request)
+    MultiJson.should have_received(:load).with(json)
+  end
+
+  it "creates channels by name" do
+    subject.events(request)
+
+    channels.each do |channel|
+      PusherFake::Channel.should have_received(:factory).with(channel)
+    end
+  end
+
+  it "emits the event to the channels" do
+    subject.events(request)
+
+    channel_1.should have_received(:emit).with(name, data, socket_id: socket_id)
+    channel_2.should have_received(:emit).with(name, data, socket_id: socket_id)
+  end
+end
+
+describe PusherFake::Server::Application, ".channels, requesting all channels" do
+  let(:request)  { stub(params: {}) }
+  let(:channels) { { "channel-1" => mock, "channel-2" => mock } }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    PusherFake::Channel.stubs(channels: channels)
+  end
+
+  it "returns a hash of all the channels" do
+    subject.channels(request).should == {
+      channels: {
+        "channel-1" => {},
+        "channel-2" => {}
+      }
+    }
+  end
+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 } }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    PusherFake::Channel.stubs(channels: channels)
+  end
+
+  it "returns a hash of the channels matching the filter" do
+    subject.channels(request).should == { 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)  { stub(params: params) }
+  let(:channel)  { stub(connections: [mock, mock]) }
+  let(:channels) { { "public-1" => mock, "presence-1" => channel } }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    PusherFake::Channel.stubs(channels: channels)
+  end
+
+  it "returns a hash of the channels matching the filter and include the user count" do
+    subject.channels(request).should == { channels: { "presence-1" => { user_count: 2 } } }
+  end
+end
+
+describe PusherFake::Server::Application, ".channels, requesting all channels with no channels occupied" do
+  let(:request)  { stub(params: {}) }
+  let(:channels) { nil }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    PusherFake::Channel.stubs(channels: channels)
+  end
+
+  it "returns a hash of no channels" do
+    subject.channels(request).should == { 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) { stub(params: params) }
+
+  subject { PusherFake::Server::Application }
+
+  it "raises an error" do
+    lambda {
+      subject.channels(request)
+    }.should raise_error(subject::CHANNEL_FILTER_ERROR)
+  end
+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(:channels) { { name => channel } }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    PusherFake::Channel.stubs(channels: channels)
+  end
+
+  it "returns a hash with the occupied status" do
+    subject.channel(name, request).should == { occupied: true }
+  end
+end
+
+describe PusherFake::Server::Application, ".channel, for an unoccupied channel" do
+  let(:name)     { "public-1" }
+  let(:request)  { stub(params: {}) }
+  let(:channel)  { stub(connections: []) }
+  let(:channels) { { name => channel } }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    PusherFake::Channel.stubs(channels: channels)
+  end
+
+  it "returns a hash with the occupied status" do
+    subject.channel(name, request).should == { occupied: false }
+  end
+end
+
+describe PusherFake::Server::Application, ".channel, for an unknown channel" do
+  let(:request)  { stub(params: {}) }
+  let(:channels) { {} }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    PusherFake::Channel.stubs(channels: channels)
+  end
+
+  it "returns a hash with the occupied status" do
+    subject.channel("fake", request).should == { occupied: false }
+  end
+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(:channels) { { name => channel } }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    PusherFake::Channel.stubs(channels: channels)
+  end
+
+  it "returns a hash with the occupied status" do
+    subject.channel(name, request).should == { 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) { stub(params: params) }
+
+  subject { PusherFake::Server::Application }
+
+  it "raises an error" do
+    lambda {
+      subject.channel("public-1", request)
+    }.should raise_error(subject::CHANNEL_USER_COUNT_ERROR)
+  end
+end
+
+describe PusherFake::Server::Application, ".users, for an occupied channel" do
+  let(:name)     { "public-1" }
+  let(:user_1)   { mock }
+  let(:user_2)   { mock }
+  let(:channel)  { stub(connections: [user_1, user_2]) }
+  let(:channels) { { name => channel } }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    PusherFake::Channel.stubs(channels: channels)
+  end
+
+  it "returns a hash with the occupied status" do
+    subject.users(name).should == { users: [
+      { id: user_1.object_id },
+      { id: user_2.object_id }
+    ] }
+  end
+end
+
+describe PusherFake::Server::Application, ".users, for an empty channel" do
+  let(:name)     { "public-1" }
+  let(:channel)  { stub(connections: []) }
+  let(:channels) { { name => channel } }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    PusherFake::Channel.stubs(channels: channels)
+  end
+
+  it "returns a hash with the occupied status" do
+    subject.users(name).should == { users: [] }
+  end
+end
+
+describe PusherFake::Server::Application, ".users, for an unknown channel" do
+  let(:channels) { {} }
+
+  subject { PusherFake::Server::Application }
+
+  before do
+    PusherFake::Channel.stubs(channels: channels)
+  end
+
+  it "returns a hash with the occupied status" do
+    subject.users("fake").should == { users: [] }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pusher-fake
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-14 00:00:00.000000000 Z
+date: 2013-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -98,7 +98,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.14.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -106,7 +106,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.14.1
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement
@@ -130,7 +130,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.11.1
+        version: 0.11.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -138,7 +138,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.11.1
+        version: 0.11.2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -235,11 +235,13 @@ files:
 - lib/pusher-fake/server.rb
 - lib/pusher-fake/webhook.rb
 - lib/pusher-fake.rb
+- features/channel.feature
 - features/channel_presence.feature
 - features/channel_subscribe.feature
 - features/channel_trigger.feature
 - features/channel_webhooks.feature
 - features/client_connect.feature
+- features/step_definitions/api_steps.rb
 - features/step_definitions/channel_steps.rb
 - features/step_definitions/client_steps.rb
 - features/step_definitions/event_steps.rb
@@ -251,8 +253,9 @@ files:
 - features/support/application.rb
 - features/support/environment.rb
 - features/support/pusher-fake.rb
-- features/support/wait.rb
+- features/support/timing.rb
 - features/support/webhooks.rb
+- features/user.feature
 - spec/lib/pusher-fake/channel/presence_spec.rb
 - spec/lib/pusher-fake/channel/private_spec.rb
 - spec/lib/pusher-fake/channel/public_spec.rb
@@ -279,7 +282,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 422324926089299174
+      hash: 399560288532115736
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -288,7 +291,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 422324926089299174
+      hash: 399560288532115736
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -296,11 +299,13 @@ signing_key:
 specification_version: 3
 summary: A fake Pusher server for development and testing.
 test_files:
+- features/channel.feature
 - features/channel_presence.feature
 - features/channel_subscribe.feature
 - features/channel_trigger.feature
 - features/channel_webhooks.feature
 - features/client_connect.feature
+- features/step_definitions/api_steps.rb
 - features/step_definitions/channel_steps.rb
 - features/step_definitions/client_steps.rb
 - features/step_definitions/event_steps.rb
@@ -312,8 +317,9 @@ test_files:
 - features/support/application.rb
 - features/support/environment.rb
 - features/support/pusher-fake.rb
-- features/support/wait.rb
+- features/support/timing.rb
 - features/support/webhooks.rb
+- features/user.feature
 - spec/lib/pusher-fake/channel/presence_spec.rb
 - spec/lib/pusher-fake/channel/private_spec.rb
 - spec/lib/pusher-fake/channel/public_spec.rb

data/features/support/wait.rb

@@ -1,9 +0,0 @@
-module Capybara
-  module Wait
-    def wait(seconds = 0.25, &block)
-      sleep(seconds) && yield
-    end
-  end
-end
-
-World(Capybara::Wait)