pusher-fake 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b6a74e962ef17c0feee10d1603d9d45b8ea2151
-  data.tar.gz: e20d2d3cb6eca5a7027f9fe6012760fd9e6148ce
+  metadata.gz: bdcb9226aaf3bc12a6ecaf05a7a8caf22bd7580f
+  data.tar.gz: bd8a9a836ccdce64bb5173db0b6d2bc1f0c35342
 SHA512:
-  metadata.gz: 0178d64c7290eb358a1433415960edcfccf78233f6cf4f5e41408d5bebaf57cd620bddafebc8603ed040186e499c87bfd424f8727b293bca18d31479b7566518
-  data.tar.gz: b0069fabf801b3dce31ad8e83611838ea98c5348e861f3da3f6df6281a435d13e07dedcac48e0c45bb627c51f75b0b4e58d5f052f5169700d447cb2ad6290c62
+  metadata.gz: 55fce89eb072245cde7dd9a6c5ecf49eb733102c1dda0e48ee80781fa2054ba9f9471eadb531333a39dad1f1cd45d63e722d95e7cbc98650c9dc6c04421cb6c0
+  data.tar.gz: 129cf3175bf0cee5d50710f4762f16ab079d89133fe1b66eca6874e408cba1a3309b1d40d0a1740e313e89759738bbe9c8a105780294379e53d31783c31742d9

data/features/step_definitions/api_steps.rb

@@ -17,22 +17,24 @@ 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
+    result.merge(key.to_sym => value)
   end
 
-  @response.should == expected
+  expect(@response).to eq(expected)
 end
 
 Then %{I should receive the following error:} do |string|
-  @error.message.should include(string.strip)
+  expect(@error.message).to 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)
+  @response[:users].tap do |users|
+    expect(users).to have(count).items
+
+    users.map do |user|
+      ObjectSpace._id2ref(user["id"])
+    end.each do |object|
+      expect(object).to be_a(PusherFake::Connection)
+    end
   end
 end

data/features/step_definitions/channel_steps.rb

@@ -1,6 +1,8 @@
 Given %{I am subscribed to the "$channel" channel} do |channel|
-  step %{I subscribe to the "#{channel}" channel}
-  step %{I should be subscribed to the "#{channel}" channel}
+  steps %{
+    When I subscribe to the "#{channel}" channel
+    Then I should be subscribed to the "#{channel}" channel
+  }
 end
 
 Given %{$name is subscribed to the "$channel" channel} do |name, channel|
@@ -78,6 +80,7 @@ Then %{I should not be subscribed to the "$channel" channel} do |channel|
       channel = Pusher.instance.channel(#{MultiJson.dump(channel)});
       channel && channel.subscribed;
     })
-    subscribed.should be_false
+
+    expect(subscribed).to be_false
   end
 end

data/features/step_definitions/client_steps.rb

@@ -1,6 +1,8 @@
 Given "I am connected" do
-  step %{I am on the homepage}
-  step %{I should be connected}
+  steps %{
+    Given I am on the homepage
+    Then I should be connected
+  }
 end
 
 Given %{$name is connected} do |name|

data/features/step_definitions/event_steps.rb

@@ -37,7 +37,8 @@ Then /^([^ ]+) should receive a "([^"]+)" event on the "([^"]+)" channel$/ do |n
   using_session(name) do
     wait do
       events = page.evaluate_script("Pusher.instance.events[#{MultiJson.dump([channel, event].join(":"))}]")
-      events.length.should == 1
+
+      expect(events).to have(1).item
     end
   end
 end
@@ -48,7 +49,8 @@ Then /^([^ ]+) should not receive a "([^"]+)" event on the "([^"]+)" channel$/ d
   using_session(name) do
     wait do
       events = page.evaluate_script("Pusher.instance.events[#{MultiJson.dump([channel, event].join(":"))}]")
-      events.should be_nil
+
+      expect(events).to be_nil
     end
   end
 end

data/features/step_definitions/presence_steps.rb

@@ -1,6 +1,6 @@
 Then /^I should see (\d+) clients?(?: with the name "([^"]+)")?$/ do |count, name|
   within("section") do
-    should have_css("header h1 span", text: count)
-    should have_css("ul li", count: count.to_i, text: name)
+    expect(page).to have_css("header h1 span", text: count)
+    expect(page).to have_css("ul li", count: count.to_i, text: name)
   end
 end

data/features/step_definitions/webhook_steps.rb

@@ -16,6 +16,6 @@ end
 
 Then /^the server should have received no events$/ do
   wait do
-    $events.should be_empty
+    expect($events).to be_empty
   end
 end

data/features/support/environment.rb

@@ -5,3 +5,9 @@ Bundler.require(:default, :development)
 
 Capybara.app = Sinatra::Application
 Capybara.javascript_driver = :webkit
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |rspec|
+    rspec.syntax = :expect
+  end
+end

data/features/support/webhooks.rb

@@ -21,7 +21,7 @@ Thread.new do
 
   EventMachine.run do
     Thin::Logging.silent = true
-    Thin::Server.start('0.0.0.0', 8082, WebhookEndpoint)
+    Thin::Server.start("0.0.0.0", 8082, WebhookEndpoint)
     Thread.current[:ready] = true
   end
 end.tap do |thread|

data/lib/pusher-fake.rb

@@ -6,7 +6,7 @@ require "thin"
 
 module PusherFake
   # The current version string.
-  VERSION = "0.13.0"
+  VERSION = "0.14.0"
 
   autoload :Channel,       "pusher-fake/channel"
   autoload :Configuration, "pusher-fake/configuration"
@@ -23,7 +23,7 @@ module PusherFake
   #
   # @yield [Configuration] The current configuration.
   def self.configure
-    yield(configuration)
+    yield configuration
   end
 
   # @return [Configuration] Current configuration.
@@ -43,4 +43,10 @@ module PusherFake
 
     "new Pusher(#{arguments})"
   end
+
+  def self.log(message)
+    if configuration.verbose
+      configuration.logger << "#{message}\n"
+    end
+  end
 end

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

@@ -21,9 +21,11 @@ module PusherFake
       def remove(connection)
         super
 
-        trigger("member_removed", channel: name, user_id: members[connection][:user_id])
+        if members.key?(connection)
+          trigger("member_removed", channel: name, user_id: members[connection][:user_id])
 
-        emit("pusher_internal:member_removed", members.delete(connection))
+          emit("pusher_internal:member_removed", members.delete(connection))
+        end
       end
 
       # Return a hash containing presence information for the channel.

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

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

data/lib/pusher-fake/configuration.rb

@@ -6,6 +6,9 @@ module PusherFake
     # @return [String] The Pusher API key. (Defaults to +PUSHER_API_KEY+.)
     attr_accessor :key
 
+    # @return [IO] An IO instance for verbose logging.
+    attr_accessor :logger
+
     # @return [String] The Pusher API token. (Defaults to +PUSHER_API_SECRET+.)
     attr_accessor :secret
 
@@ -14,6 +17,9 @@ module PusherFake
     # @return [Hash] Options for the socket server.
     attr_accessor :socket_options
 
+    # @return [Boolean] Enable verbose logging.
+    attr_accessor :verbose
+
     # Options for the web server. See +Thin::Server+ for options.
     #
     # @return [Hash] Options for the web server.
@@ -26,7 +32,9 @@ module PusherFake
     def initialize
       self.app_id   = "PUSHER_APP_ID"
       self.key      = "PUSHER_API_KEY"
+      self.logger   = STDOUT.to_io
       self.secret   = "PUSHER_API_SECRET"
+      self.verbose  = false
       self.webhooks = []
 
       self.socket_options = { host: "127.0.0.1", port: 8080 }
@@ -37,10 +45,10 @@ module PusherFake
     #
     # @param [Hash] options Custom options for Pusher client.
     def to_options(options = {})
-      options.merge({
+      options.merge(
         wsHost: socket_options[:host],
         wsPort: socket_options[:port]
-      })
+      )
     end
   end
 end

data/lib/pusher-fake/connection.rb

@@ -34,22 +34,23 @@ module PusherFake
     #
     # @param [String] data The event data as JSON.
     def process(data)
-      message      = MultiJson.load(data, symbolize_keys: true)
-      data         = message[:data]
-      event        = message[:event]
-      channel_name = message[:channel] || data.delete(:channel)
-      channel      = Channel.factory(channel_name)
+      message = MultiJson.load(data, symbolize_keys: true)
+      data    = message[:data]
+      event   = message[:event]
+      name    = message[:channel] || data.delete(: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
-        return unless channel.is_a?(Channel::Private)
-        return unless channel.includes?(self)
-
-        channel.emit(event, data, socket_id: socket.object_id)
+        if channel.is_a?(Channel::Private) && channel.includes?(self)
+          channel.emit(event, data, socket_id: socket.object_id)
+        end
       end
     end
   end

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

@@ -86,7 +86,7 @@ module PusherFake
 
         filter   = Regexp.new(%r{\A#{prefix}})
         channels = PusherFake::Channel.channels || {}
-        channels.inject({ channels: {} }) do |result, (name, channel)|
+        channels.inject(channels: {}) do |result, (name, channel)|
           unless filter && name !~ filter
             channels = result[:channels]
             channels[name] = {}

data/lib/pusher-fake/webhook.rb

@@ -2,10 +2,10 @@ module PusherFake
   class Webhook
     class << self
       def trigger(name, data = {})
-        payload = MultiJson.dump({
+        payload = MultiJson.dump(
           events:  [data.merge(name: name)],
           time_ms: Time.now.to_i
-        })
+        )
 
         PusherFake.configuration.webhooks.each do |url|
           http = EventMachine::HttpRequest.new(url)
@@ -23,7 +23,10 @@ module PusherFake
       end
 
       def signature_for(payload)
-        OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, PusherFake.configuration.secret, payload)
+        digest = OpenSSL::Digest::SHA256.new
+        secret = PusherFake.configuration.secret
+
+        OpenSSL::HMAC.hexdigest(digest, secret, payload)
       end
     end
   end

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

@@ -6,12 +6,13 @@ describe PusherFake::Channel::Presence do
   subject { PusherFake::Channel::Presence }
 
   it "inherits from private channel" do
-    subject.ancestors.should include(PusherFake::Channel::Private)
+    expect(subject.ancestors).to include(PusherFake::Channel::Private)
   end
 
   it "creates an empty members hash" do
     channel = subject.new(name)
-    channel.members.should == {}
+
+    expect(channel.members).to eq({})
   end
 end
 
@@ -35,76 +36,93 @@ describe PusherFake::Channel::Presence, "#add" do
 
   it "authorizes the connection" do
     subject.stubs(authorized?: nil)
+
     subject.add(connection, data)
-    subject.should have_received(:authorized?).with(connection, data)
+
+    expect(subject).to have_received(:authorized?).with(connection, data)
   end
 
   it "parses the channel_data when authorized" do
     subject.stubs(authorized?: true)
+
     subject.add(connection, data)
-    MultiJson.should have_received(:load).with(data[:channel_data], symbolize_keys: true)
+
+    expect(MultiJson).to have_received(:load).with(data[:channel_data], symbolize_keys: true)
   end
 
   it "assigns the parsed channel_data to the members hash for the current connection" do
     subject.stubs(authorized?: true)
+
     subject.add(connection, data)
-    subject.members[connection].should == channel_data
+
+    expect(subject.members[connection]).to eq(channel_data)
   end
 
   it "notifies the channel of the new member when authorized" do
     subject.stubs(authorized?: true)
+
     subject.add(connection, data)
-    subject.should have_received(:emit).with("pusher_internal:member_added", channel_data)
+
+    expect(subject).to have_received(:emit).with("pusher_internal:member_added", channel_data)
   end
 
   it "successfully subscribes the connection when authorized" do
     subject.stubs(authorized?: true)
+
     subject.add(connection, data)
-    connection.should have_received(:emit).with("pusher_internal:subscription_succeeded", subscription_data, subject.name)
+
+    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
     subject.stubs(authorized?: true)
+
     subject.add(connection, data)
-    connections.should have_received(:push).with(connection)
+
+    expect(connections).to have_received(:push).with(connection)
   end
 
   it "triggers channel occupied webhook for the first connection added when authorized" do
     subject.unstub(:connections)
     subject.stubs(authorized?: true)
 
-    subject.add(connection, data)
-    PusherFake::Webhook.should have_received(:trigger).with("channel_occupied", channel: name).once
-    subject.add(connection, data)
-    PusherFake::Webhook.should have_received(:trigger).with("channel_occupied", channel: name).once
+    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
     subject.stubs(authorized?: true)
+
     subject.add(connection, data)
-    PusherFake::Webhook.should have_received(:trigger).with("member_added", channel: name, user_id: user_id).once
+
+    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
     subject.stubs(authorized?: false)
+
     subject.add(connection, data)
-    connection.should have_received(:emit).with("pusher_internal:subscription_error", {}, subject.name)
+
+    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
     subject.unstub(:connections)
     subject.stubs(authorized?: false)
 
-    subject.add(connection, data)
-    PusherFake::Webhook.should have_received(:trigger).never
-    subject.add(connection, data)
-    PusherFake::Webhook.should have_received(:trigger).never
+    2.times { subject.add(connection, data) }
+
+    expect(PusherFake::Webhook).to have_received(:trigger).never
   end
 
   it "does not trigger the member added webhook when not authorized" do
     subject.stubs(authorized?: false)
+
     subject.add(connection, data)
-    PusherFake::Webhook.should have_received(:trigger).never
+
+    expect(PusherFake::Webhook).to have_received(:trigger).never
   end
 end
 
@@ -124,22 +142,57 @@ describe PusherFake::Channel::Presence, "#remove" do
 
   it "removes the connection from the channel" do
     subject.remove(connection)
-    subject.connections.should be_empty
+
+    expect(subject.connections).to be_empty
   end
 
   it "removes the connection from the members hash" do
     subject.remove(connection)
-    subject.members.should_not have_key(connection)
+
+    expect(subject.members).to_not have_key(connection)
   end
 
   it "triggers the member removed webhook" do
     subject.remove(connection)
-    PusherFake::Webhook.should have_received(:trigger).with("member_removed", channel: name, user_id: user_id).once
+
+    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)
-    subject.should have_received(:emit).with("pusher_internal:member_removed", channel_data)
+
+    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
+  let(:name)         { "name" }
+  let(:user_id)      { "1234" }
+  let(:connection)   { stub }
+  let(:channel_data) { { user_id: user_id } }
+
+  subject { PusherFake::Channel::Presence.new(name) }
+
+  before do
+    subject.stubs(connections: [], emit: nil, trigger: nil)
+  end
+
+  it "does not raise an error" do
+    expect {
+      subject.remove(connection)
+    }.to_not raise_error
+  end
+
+  it "does not trigger an event" do
+    subject.remove(connection)
+
+    expect(PusherFake::Webhook).to have_received(:trigger).with("member_removed", channel: name, user_id: user_id).never
+  end
+
+  it "does not emit an event" do
+    subject.remove(connection)
+
+    expect(subject).to have_received(:emit).with("pusher_internal:member_removed", channel_data).never
   end
 end
 
@@ -155,22 +208,26 @@ describe PusherFake::Channel::Presence, "#subscription_data" do
   end
 
   it "returns hash with presence information" do
-    subject.subscription_data.should == {
+    data = subject.subscription_data
+
+    expect(data).to eq({
       presence: {
         hash:  { member[:user_id] => member[:user_info] },
         count: 1
       }
-    }
+    })
   end
 
   it "handles multiple members" do
     members[stub] = other
 
-    subject.subscription_data.should == {
+    data = subject.subscription_data
+
+    expect(data).to eq({
       presence: {
         hash:  { member[:user_id] => member[:user_info], other[:user_id] => other[:user_info] },
         count: 2
       }
-    }
+    })
   end
 end