pusher-fake 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8c976f869c3748f43a742935c8acad5cde44975
-  data.tar.gz: db6247945298f77491265ae3286ea5f74919b0df
+  metadata.gz: a2900ffcdf8c54ba90ada932afc74bd755bf5155
+  data.tar.gz: 01f7a685ef41b5c5c155220a87576f095a9e941e
 SHA512:
-  metadata.gz: 6bf7fa18cb12730f9605d35e305ee17d9a47f2504ac539f69413e382a84f9057774960536b2dbf2dd813ec84082e3265efd6f4967eb5029167bdfef1c35c088f
-  data.tar.gz: a69826309bcd9da0fe4882cc5f153303aa46a7397ba977ca1497f68cae6cc8c3ba342cc901f27b08dd0be3dfb14dfaaff0136123d98887676823365fa159545d
+  metadata.gz: 9b7245c91e900ff1406d89cc106df53a691558a0f47526c7df0363ada92365f0773d7cd93a2ba4081e0a87fa13fd0b61e9d2f3b8ba946304895a2a5d28377158
+  data.tar.gz: 6c0b75ac27837cf28d8267ef4cdec7553763c2647985a1a3011b1604eada70bb264204f7822c69b36d69b202cbfc987c833fa523960828f503b0a994319e2f72

data/lib/pusher-fake.rb

@@ -1,12 +1,15 @@
+# rubocop:disable Style/FileName
+
 require "em-http-request"
 require "em-websocket"
 require "multi_json"
 require "openssl"
 require "thin"
 
+# A Pusher fake.
 module PusherFake
   # The current version string.
-  VERSION = "1.6.0"
+  VERSION = "1.7.0".freeze
 
   autoload :Channel,       "pusher-fake/channel"
   autoload :Configuration, "pusher-fake/configuration"

data/lib/pusher-fake/channel.rb

@@ -1,4 +1,5 @@
 module PusherFake
+  # Channel creation and management.
   module Channel
     autoload :Public,   "pusher-fake/channel/public"
     autoload :Private,  "pusher-fake/channel/private"
@@ -6,13 +7,18 @@ module PusherFake
 
     class << self
       # Name matcher for private channels.
-      PRIVATE_CHANNEL_MATCHER  = /\Aprivate-/.freeze
+      PRIVATE_CHANNEL_MATCHER  = /\Aprivate-/
 
       # Name matcher for presence channels.
-      PRESENCE_CHANNEL_MATCHER = /\Apresence-/.freeze
+      PRESENCE_CHANNEL_MATCHER = /\Apresence-/
 
       # @return [Hash] Cache of existing channels.
-      attr_accessor :channels
+      attr_writer :channels
+
+      # @return [Hash] Cache of existing channels.
+      def channels
+        @channels ||= {}
+      end
 
       # Create a channel, determining the type by the name.
       #

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

@@ -1,5 +1,6 @@
 module PusherFake
   module Channel
+    # A presence channel.
     class Presence < Private
       # @return [Hash] Channel members hash.
       attr_reader :members
@@ -21,11 +22,12 @@ module PusherFake
       def remove(connection)
         super
 
-        if members.key?(connection)
-          trigger("member_removed", channel: name, user_id: members[connection][:user_id])
+        return unless members.key?(connection)
 
-          emit("pusher_internal:member_removed", members.delete(connection))
-        end
+        trigger("member_removed",
+                channel: name, user_id: members[connection][:user_id])
+
+        emit("pusher_internal:member_removed", members.delete(connection))
       end
 
       # Return a hash containing presence information for the channel.
@@ -33,9 +35,7 @@ module PusherFake
       # @return [Hash] Hash containing presence information.
       def subscription_data
         hash = Hash[
-          members.map { |_, member|
-            [member[:user_id], member[:user_info]]
-          }
+          members.map { |_, member| [member[:user_id], member[:user_info]] }
         ]
 
         { presence: { hash: hash, count: members.size } }
@@ -48,10 +48,12 @@ module PusherFake
       #
       # Also trigger the member_added webhook.
       #
-      # @param [Connection] connection The connection a subscription succeeded for.
+      # @param [Connection] connection Connection a subscription succeeded for.
       # @param [Hash] options The options for the channel.
       def subscription_succeeded(connection, options = {})
-        member = members[connection] = MultiJson.load(options[:channel_data], symbolize_keys: true)
+        member = members[connection] = MultiJson.load(
+          options[:channel_data], symbolize_keys: true
+        )
 
         emit("pusher_internal:member_added", member)
 

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

@@ -1,12 +1,13 @@
 module PusherFake
   module Channel
+    # A private channel.
     class Private < Public
       # Add the connection to the channel if they are authorized.
       #
       # @param [Connection] connection The connection to add.
       # @param [Hash] options The options for the channel.
       # @option options [String] :auth The authentication string.
-      # @option options [Hash] :channel_data The ID and information for the subscribed client.
+      # @option options [Hash] :channel_data Information for subscribed client.
       def add(connection, options = {})
         if authorized?(connection, options)
           subscription_succeeded(connection, options)
@@ -22,7 +23,8 @@ module PusherFake
       # @option options [String] :auth The authentication string.
       # @return [Boolean] +true+ if authorized, +false+ otherwise.
       def authorized?(connection, options)
-        authentication_for(connection.id, options[:channel_data]) == options[:auth]
+        authentication_for(connection.id, options[:channel_data]) ==
+          options[:auth]
       end
 
       # Generate an authentication string from the channel based on the
@@ -34,9 +36,10 @@ module PusherFake
       # @return [String] The authentication string.
       def authentication_for(id, data = nil)
         configuration = PusherFake.configuration
-        string        = [id, name, data].compact.map(&:to_s).join(":")
-        digest        = OpenSSL::Digest::SHA256.new
-        signature     = OpenSSL::HMAC.hexdigest(digest, configuration.secret, string)
+
+        data      = [id, name, data].compact.map(&:to_s).join(":")
+        digest    = OpenSSL::Digest::SHA256.new
+        signature = OpenSSL::HMAC.hexdigest(digest, configuration.secret, data)
 
         "#{configuration.key}:#{signature}"
       end

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

@@ -1,5 +1,6 @@
 module PusherFake
   module Channel
+    # A public channel.
     class Public
       # @return [Array] Connections in this channel.
       attr_reader :connections
@@ -38,7 +39,7 @@ module PusherFake
       # Determine if the +connection+ is in the channel.
       #
       # @param [Connection] connection The connection.
-      # @return [Boolean] +true+ if the connection is in the channel, +false+ otherwise.
+      # @return [Boolean] If the connection is in the channel or not.
       def includes?(connection)
         connections.index(connection)
       end
@@ -51,9 +52,7 @@ module PusherFake
       def remove(connection)
         connections.delete(connection)
 
-        if connections.empty?
-          trigger("channel_vacated", channel: name)
-        end
+        trigger("channel_vacated", channel: name) if connections.empty?
       end
 
       # Return subscription data for the channel.
@@ -64,6 +63,10 @@ module PusherFake
         {}
       end
 
+      def trigger(name, data = {})
+        PusherFake::Webhook.trigger(name, data)
+      end
+
       private
 
       # Notify the +connection+ of the successful subscription and add the
@@ -71,19 +74,15 @@ module PusherFake
       #
       # If it is the first connection, trigger the channel_occupied webhook.
       #
-      # @param [Connection] connection The connection a subscription succeeded for.
+      # @param [Connection] connection Connection a subscription succeeded for.
       # @param [Hash] options The options for the channel.
-      def subscription_succeeded(connection, options = {})
-        connection.emit("pusher_internal:subscription_succeeded", subscription_data, name)
-        connections.push(connection)
+      def subscription_succeeded(connection, _options = {})
+        connection.emit("pusher_internal:subscription_succeeded",
+                        subscription_data, name)
 
-        if connections.length == 1
-          trigger("channel_occupied", channel: name)
-        end
-      end
+        connections.push(connection)
 
-      def trigger(name, data = {})
-        PusherFake::Webhook.trigger(name, data)
+        trigger("channel_occupied", channel: name) if connections.length == 1
       end
     end
   end

data/lib/pusher-fake/configuration.rb

@@ -1,4 +1,5 @@
 module PusherFake
+  # Configuration class.
   class Configuration
     # @return [String] The Pusher Applicaiton ID. (Defaults to +PUSHER_APP_ID+.)
     attr_accessor :app_id
@@ -12,7 +13,7 @@ module PusherFake
     # @return [String] The Pusher API token. (Defaults to +PUSHER_API_SECRET+.)
     attr_accessor :secret
 
-    # Options for the socket server. See +EventMachine::WebSocket.start+ for options.
+    # Options for the socket server. See +EventMachine::WebSocket.start+.
     #
     # @return [Hash] Options for the socket server.
     attr_accessor :socket_options

data/lib/pusher-fake/connection.rb

@@ -1,14 +1,15 @@
 module PusherFake
+  # A client connection.
   class Connection
     # Name matcher for client events.
-    CLIENT_EVENT_MATCHER  = /\Aclient-(.+)\Z/.freeze
+    CLIENT_EVENT_MATCHER = /\Aclient-(.+)\z/
 
-    # @return [EventMachine::WebSocket::Connection] The socket object for this connection.
+    # @return [EventMachine::WebSocket::Connection] Socket for the connection.
     attr_reader :socket
 
     # Create a new {Connection} object.
     #
-    # @param [EventMachine::WebSocket::Connection] socket The socket object for the connection.
+    # @param [EventMachine::WebSocket::Connection] socket Connection object.
     def initialize(socket)
       @socket = socket
     end
@@ -39,7 +40,8 @@ module PusherFake
 
     # Notify the Pusher client that a connection has been established.
     def establish
-      emit("pusher:connection_established", socket_id: id, activity_timeout: 120)
+      emit("pusher:connection_established",
+           socket_id: id, activity_timeout: 120)
     end
 
     # Process an event.
@@ -47,41 +49,51 @@ module PusherFake
     # @param [String] data The event data as JSON.
     def process(data)
       message = MultiJson.load(data, symbolize_keys: true)
+      event   = message[:event]
 
       PusherFake.log("RECV #{id}: #{message}")
 
-      data    = message[:data]
-      event   = message[:event]
-      name    = message[:channel] || data[:channel]
-      channel = Channel.factory(name) if name
-
-      case event
-      when "pusher:subscribe"
-        channel.add(self, data)
-      when "pusher:unsubscribe"
-        channel.remove(self)
-      when "pusher:ping"
-        emit("pusher:pong")
-      when CLIENT_EVENT_MATCHER
-        if channel.is_a?(Channel::Private) && channel.includes?(self)
-          channel.emit(event, data, socket_id: id)
-
-          trigger(channel, id, event, data)
-        end
+      if event =~ CLIENT_EVENT_MATCHER
+        process_trigger(event, message)
+      else
+        process_event(event, message)
       end
     end
 
     private
 
+    def channel_for(message)
+      Channel.factory(message[:channel] || message[:data][:channel])
+    end
+
+    def process_event(event, message)
+      if event == "pusher:subscribe"
+        channel_for(message).add(self, message[:data])
+      elsif event == "pusher:unsubscribe"
+        channel_for(message).remove(self)
+      elsif event == "pusher:ping"
+        emit("pusher:pong")
+      end
+    end
+
+    def process_trigger(event, message)
+      channel = channel_for(message)
+
+      return unless channel.is_a?(Channel::Private) && channel.includes?(self)
+
+      channel.emit(event, message[:data], socket_id: id)
+
+      trigger(channel, id, event, message[:data])
+    end
+
     def trigger(channel, id, event, data)
       Thread.new do
-        hook = {
-          event:     event,
-          channel:   channel.name,
-          socket_id: id
-        }
-        hook[:data]    = MultiJson.dump(data) if data
-        hook[:user_id] = channel.members[self][:user_id] if channel.is_a?(Channel::Presence)
+        hook = { event: event, channel: channel.name, socket_id: id }
+        hook[:data] = MultiJson.dump(data) if data
+
+        if channel.is_a?(Channel::Presence)
+          hook[:user_id] = channel.members[self][:user_id]
+        end
 
         channel.trigger("client_event", hook)
       end

data/lib/pusher-fake/cucumber.rb

@@ -1,3 +1,4 @@
 require "pusher-fake/support/cucumber"
 
-warn %{[DEPRECATION] "pusher-fake/cucumber" is deprecated.  Please use "pusher-fake/support/cucumber" instead.}
+warn %([DEPRECATION] "pusher-fake/cucumber" is deprecated.) +
+     %(Please use "pusher-fake/support/cucumber" instead.)

data/lib/pusher-fake/server.rb

@@ -1,65 +1,66 @@
 module PusherFake
+  # Socket and web server manager.
   module Server
     autoload :Application, "pusher-fake/server/application"
 
-    # Start the servers.
-    #
-    # @see start_socket_server
-    # @see start_web_server
-    def self.start
-      EventMachine.run do
-        start_web_server
-        start_socket_server
+    class << self
+      # Start the servers.
+      #
+      # @see start_socket_server
+      # @see start_web_server
+      def start
+        EventMachine.run do
+          start_web_server
+          start_socket_server
+        end
       end
-    end
 
-    # Start the WebSocket server.
-    def self.start_socket_server
-      EventMachine::WebSocket.start(configuration.socket_options) do |socket|
-        socket.onopen do
-          connection = Connection.new(socket)
-          connection.establish
+      # Start the WebSocket server.
+      def start_socket_server
+        EventMachine::WebSocket.start(configuration.socket_options) do |socket|
+          socket.onopen do
+            connection = Connection.new(socket)
+            connection.establish
 
-          socket.onmessage do |data|
-            connection.process(data)
-          end
-          socket.onclose do
-            Channel.remove(connection)
+            socket.onmessage { |data| connection.process(data) }
+            socket.onclose   { Channel.remove(connection) }
           end
         end
       end
-    end
 
-    # Start the web server.
-    def self.start_web_server
-      options = configuration.web_options.dup
+      # Start the web server.
+      def start_web_server
+        options = configuration.web_options.dup
+        host    = options.delete(:host)
+        port    = options.delete(:port)
 
-      Thin::Logging.silent = true
-      Thin::Server.new(options.delete(:host), options.delete(:port), Application).tap do |server|
-        options.each do |key, value|
-          server.__send__("#{key}=", value)
-        end
+        Thin::Logging.silent = true
+        Thin::Server.new(host, port, Application).tap do |server|
+          options.each do |key, value|
+            server.__send__("#{key}=", value)
+          end
 
-        server.start!
+          server.start!
+        end
       end
-    end
 
-    private
+      private
 
-    # Convenience method for access the configuration object.
-    #
-    # @return [Configuration] The configuration object.
-    def self.configuration
-      PusherFake.configuration
-    end
+      # Convenience method for access the configuration object.
+      #
+      # @return [Configuration] The configuration object.
+      def configuration
+        PusherFake.configuration
+      end
 
-    # Return a hash of options for the socket server based on
-    # the configuration.
-    #
-    # @return [Hash] The socket server configuration options.
-    def self.socket_server_options
-      { host: configuration.socket_host,
-        port: configuration.socket_port }
+      # Return a hash of options for the socket server based on
+      # the configuration.
+      #
+      # @return [Hash] The socket server configuration options.
+      def socket_server_options
+        { host: configuration.socket_host,
+          port: configuration.socket_port }
+      end
     end
   end
 end

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

@@ -1,54 +1,58 @@
 module PusherFake
   module Server
+    # The fake web application.
     class Application
-      CHANNEL_FILTER_ERROR = "user_count may only be requested for presence channels - " +
-                               "please supply filter_by_prefix begining with presence-".freeze
+      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
+      CHANNEL_USER_COUNT_ERROR = "Cannot retrieve the user count unless the " \
+                                 "channel is a presence channel".freeze
 
-      PRESENCE_PREFIX_MATCHER = /\Apresence-/.freeze
+      PRESENCE_PREFIX_MATCHER = /\Apresence-/
+
+      REQUEST_PATHS = {
+        %r{\A/apps/:id/batch_events\z}           => :batch_events,
+        %r{\A/apps/:id/events\z}                 => :events,
+        %r{\A/apps/:id/channels\z}               => :channels,
+        %r{\A/apps/:id/channels/([^/]+)\z}       => :channel,
+        %r{\A/apps/:id/channels/([^/]+)/users\z} => :users
+      }.freeze
 
       # Process an API request.
       #
       # @param [Hash] environment The request environment.
       # @return [Rack::Response] A successful response.
       def self.call(environment)
-        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)
-                   else
-                     raise "Unknown path: #{request.path}"
-                   end
+        response = response_for(request)
 
         Rack::Response.new(MultiJson.dump(response)).finish
       rescue => error
         Rack::Response.new(error.message, 400).finish
       end
 
+      # Emit batch events with data to the requested channel(s).
+      #
+      # @param [Rack::Request] request The HTTP request.
+      # @return [Hash] An empty hash.
+      def self.batch_events(request)
+        batch = MultiJson.load(request.body.read)["batch"]
+        batch.each do |event|
+          send_event(event)
+        end
+
+        {}
+      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)
-        data  = begin
-                  MultiJson.load(event["data"])
-                rescue MultiJson::LoadError
-                  event["data"]
-                end
 
-        event["channels"].each do |channel_name|
-          channel = Channel.factory(channel_name)
-          channel.emit(event["name"], data, socket_id: event["socket_id"])
-        end
+        send_event(event)
 
         {}
       end
@@ -62,53 +66,71 @@ module PusherFake
       # @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(",")
+        count = request.params["info"].to_s.split(",").include?("user_count")
 
-        if info.include?("user_count") && name !~ PRESENCE_PREFIX_MATCHER
+        if count && name !~ PRESENCE_PREFIX_MATCHER
           raise CHANNEL_USER_COUNT_ERROR
         end
 
-        channels = PusherFake::Channel.channels || {}
-        channel  = channels[name]
+        channel     = PusherFake::Channel.channels[name]
+        connections = channel ? channel.connections : []
 
-        {}.tap do |result|
-          result[:occupied]   = !channel.nil? && channel.connections.length > 0
-          result[:user_count] = channel.connections.length if channel && info.include?("user_count")
-        end
+        result = { occupied: connections.any? }
+        result[:user_count] = connections.size if count
+        result
       end
 
-      # Returns a hash of occupied channels, optionally filtering with a prefix.
-      #
-      # When filtering to presence chanenls, the user count maybe also be requested.
+      # 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.
+      #
+      # rubocop:disable Metrics/AbcSize
       def self.channels(request)
-        info   = request.params["info"].to_s.split(",")
+        count  = request.params["info"].to_s.split(",").include?("user_count")
         prefix = request.params["filter_by_prefix"].to_s
 
-        if info.include?("user_count") && prefix !~ PRESENCE_PREFIX_MATCHER
-          raise CHANNEL_FILTER_ERROR
-        end
+        raise CHANNEL_FILTER_ERROR if count && prefix !~ PRESENCE_PREFIX_MATCHER
 
-        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")
+        PusherFake::Channel
+          .channels
+          .each_with_object(channels: {}) do |(name, channel), result|
+            next unless name.start_with?(prefix)
+
+            channels = result[:channels].merge!(name => {})
+            channels[name][:user_count] = channel.connections.size if count
           end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # Attempt to provide a response for the provided request.
+      #
+      # @param [Rack::Request] request The HTTP request.
+      # @return [Hash] A response hash.
+      def self.response_for(request)
+        id = PusherFake.configuration.app_id
 
-          result
+        REQUEST_PATHS.each do |path, method|
+          matcher = Regexp.new(path.to_s.sub(":id", id))
+          matches = matcher.match(request.path)
+
+          next if matches.nil?
+
+          arguments = [matches[1], request].compact
+
+          return public_send(method, *arguments)
         end
+
+        raise "Unknown path: #{request.path}"
       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)
+      def self.users(name, _request = nil)
         channels = PusherFake::Channel.channels || {}
         channel  = channels[name]
 
@@ -120,6 +142,23 @@ module PusherFake
 
         { users: users || [] }
       end
+
+      private_class_method
+
+      # Emit an event with data to the requested channel(s).
+      #
+      # @param [Hash] event The raw event JSON.
+      #
+      # rubocop:disable Style/RescueModifier
+      def self.send_event(event)
+        data     = MultiJson.load(event["data"]) rescue event["data"]
+        channels = Array(event["channels"] || event["channel"])
+        channels.each do |channel_name|
+          channel = Channel.factory(channel_name)
+          channel.emit(event["name"], data, socket_id: event["socket_id"])
+        end
+      end
+      # rubocop:enable Style/RescueModifier
     end
   end
 end