pusher-fake 0.14.0 → 1.0.0

data/features/support/application/views/index.erb

@@ -13,7 +13,7 @@
   <ul></ul>
 </section>
 
-<script src="/javascripts/vendor/pusher-2.1.6.js"></script>
+<script src="/javascripts/vendor/pusher-2.2.1.js"></script>
 <script>
 window.addEventListener("DOMContentLoaded", function() {
   // Create the client instance using the PusherFake server.

data/features/support/webhooks.rb

@@ -22,15 +22,9 @@ Thread.new do
   EventMachine.run do
     Thin::Logging.silent = true
     Thin::Server.start("0.0.0.0", 8082, WebhookEndpoint)
-    Thread.current[:ready] = true
   end
 end.tap do |thread|
   at_exit { thread.exit }
-
-  # Wait for the webhook endpoint server to start.
-  Timeout::timeout(5) do
-    sleep(0.05) until thread[:ready]
-  end
 end
 
-PusherFake.configuration.webhooks = ["http://localhost:8082"]
+PusherFake.configuration.webhooks = ["http://127.0.0.1:8082"]

data/lib/pusher-fake.rb

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

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

@@ -22,7 +22,7 @@ module PusherFake
       # @option options [String] :auth The authentication string.
       # @return [Boolean] +true+ if authorized, +false+ otherwise.
       def authorized?(connection, options)
-        authentication_for(connection.socket.object_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

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

@@ -29,7 +29,7 @@ module PusherFake
       # @param [Hash] data The event data.
       def emit(event, data, options = {})
         connections.each do |connection|
-          unless connection.socket.object_id == options[:socket_id]
+          unless connection.id == options[:socket_id]
             connection.emit(event, data, name)
           end
         end

data/lib/pusher-fake/connection.rb

@@ -13,21 +13,30 @@ module PusherFake
       @socket = socket
     end
 
+    # The ID of the connection.
+    #
+    # @return [Integer] The object ID of the socket.
+    def id
+      socket.object_id.to_s
+    end
+
     # Emit an event to the connection.
     #
     # @param [String] event The event name.
     # @param [Hash] data The event data.
     # @param [String] channel The channel name.
     def emit(event, data = {}, channel = nil)
-      message = { event: event, data: data }
+      message = { event: event, data: MultiJson.dump(data) }
       message[:channel] = channel if channel
 
+      PusherFake.log("SEND #{id}: #{message}")
+
       socket.send(MultiJson.dump(message))
     end
 
     # Notify the Pusher client that a connection has been established.
     def establish
-      emit("pusher:connection_established", socket_id: socket.object_id, activity_timeout: 120)
+      emit("pusher:connection_established", socket_id: id, activity_timeout: 120)
     end
 
     # Process an event.
@@ -35,9 +44,12 @@ module PusherFake
     # @param [String] data The event data as JSON.
     def process(data)
       message = MultiJson.load(data, symbolize_keys: true)
+
+      PusherFake.log("RECV #{id}: #{message}")
+
       data    = message[:data]
       event   = message[:event]
-      name    = message[:channel] || data.delete(:channel)
+      name    = message[:channel] || data[:channel]
       channel = Channel.factory(name) if name
 
       case event
@@ -49,9 +61,27 @@ module PusherFake
         emit("pusher:pong")
       when CLIENT_EVENT_MATCHER
         if channel.is_a?(Channel::Private) && channel.includes?(self)
-          channel.emit(event, data, socket_id: socket.object_id)
+          channel.emit(event, data, socket_id: id)
+
+          trigger(channel, id, event, data)
         end
       end
     end
+
+    private
+
+    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)
+
+        channel.trigger("client_event", hook)
+      end
+    end
   end
 end

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

@@ -39,8 +39,15 @@ module PusherFake
       # @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"])
+        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
 
         {}
@@ -107,7 +114,7 @@ module PusherFake
 
         if channel
           users = channel.connections.map do |connection|
-            { id: connection.object_id }
+            { id: connection.id }
           end
         end
 

data/lib/pusher-fake/webhook.rb

@@ -7,6 +7,7 @@ module PusherFake
           time_ms: Time.now.to_i
         )
 
+        PusherFake.log("HOOK: #{payload}")
         PusherFake.configuration.webhooks.each do |url|
           http = EventMachine::HttpRequest.new(url)
           http.post(body: payload, head: headers_for(payload))

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

@@ -133,8 +133,7 @@ end
 describe PusherFake::Channel::Private, "#authorized?" do
   let(:data)           { { auth: authentication, channel_data: channel_data } }
   let(:name)           { "private-channel" }
-  let(:socket)         { stub }
-  let(:connection)     { stub(socket: socket) }
+  let(:connection)     { stub(id: "1") }
   let(:channel_data)   { "{}" }
   let(:authentication) { "authentication" }
 
@@ -144,10 +143,10 @@ describe PusherFake::Channel::Private, "#authorized?" do
     subject.stubs(:authentication_for)
   end
 
-  it "generates authentication for the connection socket ID" do
+  it "generates authentication for the connection ID" do
     subject.authorized?(connection, data)
 
-    expect(subject).to have_received(:authentication_for).with(socket.object_id, channel_data)
+    expect(subject).to have_received(:authentication_for).with(connection.id, channel_data)
   end
 
   it "returns true if the authentication matches" do

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

@@ -55,11 +55,9 @@ describe PusherFake::Channel, "#emit" do
   let(:data)         { stub }
   let(:name)         { "name" }
   let(:event)        { "event" }
-  let(:socket_1)     { stub }
-  let(:socket_2)     { stub }
   let(:connections)  { [connection_1, connection_2] }
-  let(:connection_1) { stub(emit: nil, socket: socket_1) }
-  let(:connection_2) { stub(emit: nil, socket: socket_2) }
+  let(:connection_1) { stub(emit: nil, id: "1") }
+  let(:connection_2) { stub(emit: nil, id: "2") }
 
   subject { PusherFake::Channel::Public.new(name) }
 
@@ -74,8 +72,8 @@ describe PusherFake::Channel, "#emit" do
     expect(connection_2).to have_received(:emit).with(event, data, name)
   end
 
-  it "ignores connection if socket_id matches the connections socket object_id" do
-    subject.emit(event, data, socket_id: socket_2.object_id)
+  it "ignores connection if socket_id matches the connections ID" 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

data/spec/lib/pusher-fake/connection_spec.rb

@@ -1,5 +1,28 @@
 require "spec_helper"
 
+shared_examples_for "#process" do
+  let(:json) { stub }
+
+  subject { PusherFake::Connection.new(stub) }
+
+  before do
+    PusherFake.stubs(:log)
+    MultiJson.stubs(load: message)
+  end
+
+  it "parses the JSON data" do
+    subject.process(json)
+
+    expect(MultiJson).to have_received(:load).with(json, symbolize_keys: true)
+  end
+
+  it "logs receiving the event" do
+    subject.process(json)
+
+    expect(PusherFake).to have_received(:log).with("RECV #{subject.id}: #{message}")
+  end
+end
+
 describe PusherFake::Connection do
   let(:socket) { stub }
 
@@ -18,11 +41,15 @@ describe PusherFake::Connection, "#emit" do
   let(:event)        { "name" }
   let(:socket)       { stub(:send) }
   let(:channel)      { "channel" }
-  let(:message)      { { event: event, data: data } }
+  let(:message)      { { event: event, data: MultiJson.dump(data) } }
   let(:channel_json) { MultiJson.dump(message.merge(channel: channel)) }
 
   subject { PusherFake::Connection.new(socket) }
 
+  before do
+    PusherFake.stubs(:log)
+  end
+
   it "sends the event to the socket as JSON" do
     subject.emit(event, data)
 
@@ -34,6 +61,12 @@ describe PusherFake::Connection, "#emit" do
 
     expect(socket).to have_received(:send).with(channel_json)
   end
+
+  it "logs sending the event" do
+    subject.emit(event, data)
+
+    expect(PusherFake).to have_received(:log).with("SEND #{subject.id}: #{message}")
+  end
 end
 
 describe PusherFake::Connection, "#establish" do
@@ -45,204 +78,225 @@ describe PusherFake::Connection, "#establish" do
     subject.stubs(:emit)
   end
 
-  it "emits the connection established event with the socket ID" do
+  it "emits the connection established event with the connection ID" do
     subject.establish
 
     expect(subject).to have_received(:emit)
-      .with("pusher:connection_established", socket_id: socket.object_id, activity_timeout: 120)
+      .with("pusher:connection_established", socket_id: subject.id, activity_timeout: 120)
   end
 end
 
-describe PusherFake::Connection, "#process, with a subscribe event" do
-  let(:data)    { { channel: name, auth: "auth" } }
-  let(:json)    { stub }
-  let(:name)    { "channel" }
-  let(:channel) { stub(add: nil) }
-  let(:message) { { event: "pusher:subscribe", data: data } }
+describe PusherFake::Connection, "#id" do
+  let(:id)     { socket.object_id.to_s }
+  let(:socket) { stub }
 
-  subject { PusherFake::Connection.new(stub) }
+  subject { PusherFake::Connection.new(socket) }
 
-  before do
-    MultiJson.stubs(load: message)
-    PusherFake::Channel.stubs(factory: channel)
+  it "returns the object ID of the socket" do
+    expect(subject.id).to eq(id)
   end
+end
 
-  it "parses the JSON data" do
-    subject.process(json)
+describe PusherFake::Connection, "#process, with a subscribe event" do
+  it_should_behave_like "#process" do
+    let(:data)    { { channel: name, auth: "auth" } }
+    let(:name)    { "channel" }
+    let(:channel) { stub(add: nil) }
+    let(:message) { { event: "pusher:subscribe", data: data } }
 
-    expect(MultiJson).to have_received(:load).with(json, symbolize_keys: true)
-  end
+    before do
+      PusherFake::Channel.stubs(factory: channel)
+    end
 
-  it "creates a channel from the event data" do
-    subject.process(json)
+    it "creates a channel from the event data" do
+      subject.process(json)
 
-    expect(PusherFake::Channel).to have_received(:factory).with(name)
-  end
+      expect(PusherFake::Channel).to have_received(:factory).with(name)
+    end
 
-  it "attempts to add the connection to the channel" do
-    subject.process(json)
+    it "attempts to add the connection to the channel" do
+      subject.process(json)
 
-    expect(channel).to have_received(:add).with(subject, data)
+      expect(channel).to have_received(:add).with(subject, data)
+    end
   end
 end
 
 describe PusherFake::Connection, "#process, with an unsubscribe event" do
-  let(:json)    { stub }
-  let(:name)    { "channel" }
-  let(:channel) { stub(remove: nil) }
-  let(:message) { { event: "pusher:unsubscribe", channel: name } }
+  it_should_behave_like "#process" do
+    let(:name)    { "channel" }
+    let(:channel) { stub(remove: nil) }
+    let(:message) { { event: "pusher:unsubscribe", channel: name } }
 
-  subject { PusherFake::Connection.new(stub) }
+    before do
+      PusherFake::Channel.stubs(factory: channel)
+    end
 
-  before do
-    MultiJson.stubs(load: message)
-    PusherFake::Channel.stubs(factory: channel)
-  end
+    it "creates a channel from the event data" do
+      subject.process(json)
 
-  it "parses the JSON data" do
-    subject.process(json)
+      expect(PusherFake::Channel).to have_received(:factory).with(name)
+    end
 
-    expect(MultiJson).to have_received(:load).with(json, symbolize_keys: true)
-  end
-
-  it "creates a channel from the event data" do
-    subject.process(json)
-
-    expect(PusherFake::Channel).to have_received(:factory).with(name)
-  end
-
-  it "removes the connection from the channel" do
-    subject.process(json)
+    it "removes the connection from the channel" do
+      subject.process(json)
 
-    expect(channel).to have_received(:remove).with(subject)
+      expect(channel).to have_received(:remove).with(subject)
+    end
   end
 end
 
 describe PusherFake::Connection, "#process, with a ping event" do
-  let(:json)    { stub }
-  let(:message) { { event: "pusher:ping", data: {} } }
+  it_should_behave_like "#process" do
+    let(:message) { { event: "pusher:ping", data: {} } }
 
-  subject { PusherFake::Connection.new(stub) }
+    before do
+      subject.stubs(:emit)
+    end
 
-  before do
-    MultiJson.stubs(load: message)
-    PusherFake::Channel.stubs(:factory)
-    subject.stubs(:emit)
-  end
+    it "does not create a channel" do
+      subject.process(json)
 
-  it "parses the JSON data" do
-    subject.process(json)
+      expect(PusherFake::Channel).to have_received(:factory).never
+    end
 
-    expect(MultiJson).to have_received(:load).with(json, symbolize_keys: true)
+    it "emits a pong event" do
+      subject.process(json)
+
+      expect(subject).to have_received(:emit).with("pusher:pong")
+    end
   end
+end
 
-  it "does not create a channel" do
-    subject.process(json)
+describe PusherFake::Connection, "#process, with a client event" do
+  it_should_behave_like "#process" do
+    let(:data)    { {} }
+    let(:name)    { "channel" }
+    let(:event)   { "client-hello-world" }
+    let(:channel) { stub(emit: nil, includes?: nil, is_a?: true) }
+    let(:message) { { event: event, data: data, channel: name } }
 
-    expect(PusherFake::Channel).to have_received(:factory).never
-  end
+    before do
+      subject.stubs(:trigger)
+      PusherFake::Channel.stubs(factory: channel)
+    end
 
-  it "emits a pong event" do
-    subject.process(json)
+    it "creates a channel from the event data" do
+      subject.process(json)
 
-    expect(subject).to have_received(:emit).with("pusher:pong")
-  end
-end
+      expect(PusherFake::Channel).to have_received(:factory).with(name)
+    end
 
-describe PusherFake::Connection, "#process, with a client event" do
-  let(:data)    { {} }
-  let(:json)    { stub }
-  let(:name)    { "channel" }
-  let(:event)   { "client-hello-world" }
-  let(:channel) { stub(emit: nil, includes?: nil, is_a?: true) }
-  let(:message) { { event: event, data: data, channel: name } }
+    it "ensures the channel is private" do
+      subject.process(json)
 
-  subject { PusherFake::Connection.new(stub) }
+      expect(channel).to have_received(:is_a?).with(PusherFake::Channel::Private)
+    end
 
-  before do
-    MultiJson.stubs(load: message)
-    PusherFake::Channel.stubs(factory: channel)
-  end
+    it "checks if the connection is in the channel" do
+      subject.process(json)
 
-  it "parses the JSON data" do
-    subject.process(json)
+      expect(channel).to have_received(:includes?).with(subject)
+    end
 
-    expect(MultiJson).to have_received(:load).with(json, symbolize_keys: true)
-  end
+    it "emits the event to the channel when the connection is in the channel" do
+      channel.stubs(includes?: true)
 
-  it "creates a channel from the event data" do
-    subject.process(json)
+      subject.process(json)
 
-    expect(PusherFake::Channel).to have_received(:factory).with(name)
-  end
+      expect(channel).to have_received(:emit).with(event, data, socket_id: subject.id)
+    end
 
-  it "ensures the channel is private" do
-    subject.process(json)
+    it "does not emit the event to the channel when the channel is not private" do
+      channel.stubs(includes?: true, is_a?: false)
 
-    expect(channel).to have_received(:is_a?).with(PusherFake::Channel::Private)
-  end
+      subject.process(json)
 
-  it "checks if the connection is in the channel" do
-    subject.process(json)
+      expect(channel).to have_received(:emit).never
+    end
+
+    it "does not emit the event to the channel when the connection is not in the channel" do
+      channel.stubs(includes?: false)
 
-    expect(channel).to have_received(:includes?).with(subject)
+      subject.process(json)
+
+      expect(channel).to have_received(:emit).never
+    end
   end
+end
 
-  it "emits the event to the channel when the connection is in the channel" do
-    channel.stubs(includes?: true)
+describe PusherFake::Connection, "#process, with a client event trigger a webhook" do
+  it_should_behave_like "#process" do
+    let(:data)    { { example: "data" } }
+    let(:name)    { "channel" }
+    let(:event)   { "client-hello-world" }
+    let(:user_id) { 1 }
+    let(:channel) { stub(name: name, emit: nil, includes?: nil) }
+    let(:message) { { event: event, channel: name } }
+    let(:options) { { channel: name, event: event, socket_id: subject.id } }
 
-    subject.process(json)
+    before do
+      channel.stubs(:trigger)
+      channel.stubs(:includes?).with(subject).returns(true)
+      channel.stubs(:is_a?).with(PusherFake::Channel::Private).returns(true)
+      channel.stubs(:is_a?).with(PusherFake::Channel::Presence).returns(false)
 
-    expect(channel).to have_received(:emit).with(event, data, socket_id: subject.socket.object_id)
-  end
+      # NOTE: Hack to avoid race condition in unit tests.
+      Thread.stubs(:new).yields
 
-  it "does not emit the event to the channel when the channel is not private" do
-    channel.stubs(includes?: true, is_a?: false)
+      PusherFake::Channel.stubs(factory: channel)
+    end
 
-    subject.process(json)
+    it "triggers the client event webhook" do
+      subject.process(json)
 
-    expect(channel).to have_received(:emit).never
-  end
+      expect(channel).to have_received(:trigger)
+        .with("client_event", options).once
+    end
 
-  it "does not emit the event to the channel when the connection is not in the channel" do
-    channel.stubs(includes?: false)
+    it "includes data in event when present" do
+      message[:data] = data
 
-    subject.process(json)
+      subject.process(json)
 
-    expect(channel).to have_received(:emit).never
-  end
-end
+      expect(channel).to have_received(:trigger).
+        with("client_event", options.merge(data: MultiJson.dump(data))).once
+    end
 
-describe PusherFake::Connection, "#process, with an unknown event" do
-  let(:data)    { {} }
-  let(:json)    { stub }
-  let(:name)    { "channel" }
-  let(:event)   { "hello-world" }
-  let(:channel) { stub(emit: nil) }
-  let(:message) { { event: event, data: data, channel: name } }
+    it "includes user ID in event when on a presence channel" do
+      channel.stubs(:is_a?).with(PusherFake::Channel::Presence).returns(true)
+      channel.stubs(members: { subject => { user_id: user_id } })
 
-  subject { PusherFake::Connection.new(stub) }
+      subject.process(json)
 
-  before do
-    MultiJson.stubs(load: message)
-    PusherFake::Channel.stubs(factory: channel)
+      expect(channel).to have_received(:trigger).
+        with("client_event", options.merge(user_id: user_id)).once
+    end
   end
+end
 
-  it "parses the JSON data" do
-    subject.process(json)
+describe PusherFake::Connection, "#process, with an unknown event" do
+  it_should_behave_like "#process" do
+    let(:data)    { {} }
+    let(:name)    { "channel" }
+    let(:event)   { "hello-world" }
+    let(:channel) { stub(emit: nil) }
+    let(:message) { { event: event, data: data, channel: name } }
 
-    expect(MultiJson).to have_received(:load).with(json, symbolize_keys: true)
-  end
+    before do
+      PusherFake::Channel.stubs(factory: channel)
+    end
 
-  it "creates a channel from the event data" do
-    subject.process(json)
+    it "creates a channel from the event data" do
+      subject.process(json)
 
-    expect(PusherFake::Channel).to have_received(:factory).with(name)
-  end
+      expect(PusherFake::Channel).to have_received(:factory).with(name)
+    end
 
-  it "does not emit the event" do
-    subject.process(json)
+    it "does not emit the event" do
+      subject.process(json)
 
-    expect(channel).to have_received(:emit).never
+      expect(channel).to have_received(:emit).never
+    end
   end
 end