pusher-fake 0.13.0 → 0.14.0

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

@@ -4,7 +4,7 @@ describe PusherFake::Channel::Private do
   subject { PusherFake::Channel::Private }
 
   it "inherits from public channel" do
-    subject.ancestors.should include(PusherFake::Channel::Public)
+    expect(subject.ancestors).to include(PusherFake::Channel::Public)
   end
 end
 
@@ -24,46 +24,52 @@ describe PusherFake::Channel::Private, "#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 "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 "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", {}, subject.name)
+
+    expect(connection).to have_received(:emit).with("pusher_internal:subscription_succeeded", {}, subject.name)
   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 "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
 end
 
@@ -83,11 +89,15 @@ describe PusherFake::Channel::Private, "#authentication_for" do
 
   it "generates a signature" do
     subject.authentication_for(id)
-    OpenSSL::HMAC.should have_received(:hexdigest).with(kind_of(OpenSSL::Digest::SHA256), configuration.secret, string)
+
+    expect(OpenSSL::HMAC).to have_received(:hexdigest)
+      .with(kind_of(OpenSSL::Digest::SHA256), configuration.secret, string)
   end
 
   it "returns the authentication string" do
-    subject.authentication_for(id).should == "#{configuration.key}:#{signature}"
+    string = subject.authentication_for(id)
+
+    expect(string).to eq("#{configuration.key}:#{signature}")
   end
 end
 
@@ -108,11 +118,15 @@ describe PusherFake::Channel::Private, "#authentication_for, with channel data"
 
   it "generates a signature" do
     subject.authentication_for(id, channel_data)
-    OpenSSL::HMAC.should have_received(:hexdigest).with(kind_of(OpenSSL::Digest::SHA256), configuration.secret, string)
+
+    expect(OpenSSL::HMAC).to have_received(:hexdigest)
+      .with(kind_of(OpenSSL::Digest::SHA256), configuration.secret, string)
   end
 
   it "returns the authentication string" do
-    subject.authentication_for(id, channel_data).should == "#{configuration.key}:#{signature}"
+    string = subject.authentication_for(id, channel_data)
+
+    expect(string).to eq("#{configuration.key}:#{signature}")
   end
 end
 
@@ -132,16 +146,19 @@ describe PusherFake::Channel::Private, "#authorized?" do
 
   it "generates authentication for the connection socket ID" do
     subject.authorized?(connection, data)
-    subject.should have_received(:authentication_for).with(socket.object_id, channel_data)
+
+    expect(subject).to have_received(:authentication_for).with(socket.object_id, channel_data)
   end
 
   it "returns true if the authentication matches" do
     subject.stubs(authentication_for: authentication)
-    subject.authorized?(connection, data).should be_true
+
+    expect(subject).to be_authorized(connection, data)
   end
 
   it "returns false if the authentication matches" do
     subject.stubs(authentication_for: "")
-    subject.authorized?(connection, data).should be_false
+
+    expect(subject).to_not be_authorized(connection, data)
   end
 end

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

@@ -7,12 +7,14 @@ describe PusherFake::Channel::Public do
 
   it "assigns the provided name" do
     channel = subject.new(name)
-    channel.name.should == name
+
+    expect(channel.name).to eq(name)
   end
 
   it "creates an empty connections array" do
     channel = subject.new(name)
-    channel.connections.should == []
+
+    expect(channel.connections).to eq([])
   end
 end
 
@@ -30,21 +32,22 @@ describe PusherFake::Channel, "#add" do
 
   it "adds the connection" do
     subject.add(connection)
-    connections.should have_received(:push).with(connection)
+
+    expect(connections).to have_received(:push).with(connection)
   end
 
   it "successfully subscribes the connection" do
     subject.add(connection)
-    connection.should have_received(:emit).with("pusher_internal:subscription_succeeded", {}, subject.name)
+
+    expect(connection).to have_received(:emit).with("pusher_internal:subscription_succeeded", {}, subject.name)
   end
 
   it "triggers channel occupied webhook for the first connection added" do
     subject.unstub(:connections)
 
-    subject.add(connection)
-    PusherFake::Webhook.should have_received(:trigger).with("channel_occupied", channel: name).once
-    subject.add(connection)
-    PusherFake::Webhook.should have_received(:trigger).with("channel_occupied", channel: name).once
+    2.times { subject.add(connection) }
+
+    expect(PusherFake::Webhook).to have_received(:trigger).with("channel_occupied", channel: name).once
   end
 end
 
@@ -66,14 +69,16 @@ describe PusherFake::Channel, "#emit" do
 
   it "emits the event for each connection in the channel" do
     subject.emit(event, data)
-    connection_1.should have_received(:emit).with(event, data, name)
-    connection_2.should have_received(:emit).with(event, data, name)
+
+    expect(connection_1).to have_received(:emit).with(event, data, name)
+    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)
-    connection_1.should have_received(:emit).with(event, data, name)
-    connection_2.should have_received(:emit).never
+
+    expect(connection_1).to have_received(:emit).with(event, data, name)
+    expect(connection_2).to have_received(:emit).never
   end
 end
 
@@ -84,12 +89,14 @@ describe PusherFake::Channel, "#includes?" do
 
   it "returns true if the connection is in the channel" do
     subject.stubs(connections: [connection])
-    subject.includes?(connection).should be_true
+
+    expect(subject).to be_includes(connection)
   end
 
   it "returns false if the connection is not in the channel" do
     subject.stubs(connections: [])
-    subject.includes?(connection).should be_false
+
+    expect(subject).to_not be_includes(connection)
   end
 end
 
@@ -107,14 +114,18 @@ describe PusherFake::Channel, "#remove" do
 
   it "removes the connection from the channel" do
     subject.remove(connection_1)
-    subject.connections.should_not include(connection_1)
+
+    expect(subject.connections).to_not include(connection_1)
   end
 
   it "triggers channel vacated webhook when all connections are removed" do
     subject.remove(connection_1)
-    PusherFake::Webhook.should have_received(:trigger).never
+
+    expect(PusherFake::Webhook).to have_received(:trigger).never
+
     subject.remove(connection_2)
-    PusherFake::Webhook.should have_received(:trigger).with("channel_vacated", channel: name).once
+
+    expect(PusherFake::Webhook).to have_received(:trigger).with("channel_vacated", channel: name).once
   end
 end
 
@@ -122,6 +133,6 @@ describe PusherFake::Channel::Public, "#subscription_data" do
   subject { PusherFake::Channel::Public.new("name") }
 
   it "returns an empty hash" do
-    subject.subscription_data.should == {}
+    expect(subject.subscription_data).to eq({})
   end
 end

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

@@ -16,16 +16,23 @@ describe PusherFake::Channel, ".factory" do
 
   it "caches the channel" do
     PusherFake::Channel::Public.unstub(:new)
-    subject.factory(name).should == subject.factory(name)
+
+    factory_1 = subject.factory(name)
+    factory_2 = subject.factory(name)
+
+    expect(factory_1).to eq(factory_2)
   end
 
   it "creates a public channel by name" do
     subject.factory(name)
-    PusherFake::Channel::Public.should have_received(:new).with(name)
+
+    expect(PusherFake::Channel::Public).to have_received(:new).with(name)
   end
 
   it "returns the channel instance" do
-    subject.factory(name).should == channel
+    factory = subject.factory(name)
+
+    expect(factory).to eq(channel)
   end
 end
 
@@ -45,16 +52,23 @@ describe PusherFake::Channel, ".factory, for a private channel" do
 
   it "caches the channel" do
     PusherFake::Channel::Private.unstub(:new)
-    subject.factory(name).should == subject.factory(name)
+
+    factory_1 = subject.factory(name)
+    factory_2 = subject.factory(name)
+
+    expect(factory_1).to eq(factory_2)
   end
 
   it "creates a private channel by name" do
     subject.factory(name)
-    PusherFake::Channel::Private.should have_received(:new).with(name)
+
+    expect(PusherFake::Channel::Private).to have_received(:new).with(name)
   end
 
   it "returns the channel instance" do
-    subject.factory(name).should == channel
+    factory = subject.factory(name)
+
+    expect(factory).to eq(channel)
   end
 end
 
@@ -74,16 +88,23 @@ describe PusherFake::Channel, ".factory, for a presence channel" do
 
   it "caches the channel" do
     PusherFake::Channel::Presence.unstub(:new)
-    subject.factory(name).should == subject.factory(name)
+
+    factory_1 = subject.factory(name)
+    factory_2 = subject.factory(name)
+
+    expect(factory_1).to eq(factory_2)
   end
 
   it "creates a presence channel by name" do
     subject.factory(name)
-    PusherFake::Channel::Presence.should have_received(:new).with(name)
+
+    expect(PusherFake::Channel::Presence).to have_received(:new).with(name)
   end
 
   it "returns the channel instance" do
-    subject.factory(name).should == channel
+    factory = subject.factory(name)
+
+    expect(factory).to eq(channel)
   end
 end
 
@@ -101,23 +122,29 @@ describe PusherFake::Channel, ".remove" do
 
   it "removes the connection from all channels" do
     subject.remove(connection)
-    channel_1.should have_received(:remove).with(connection)
-    channel_2.should have_received(:remove).with(connection)
+
+    expect(channel_1).to have_received(:remove).with(connection)
+    expect(channel_2).to have_received(:remove).with(connection)
   end
 
   it "deletes a channel with no connections remaining" do
     subject.remove(connection)
-    channels.should_not have_key(:channel_1)
+
+    expect(channels).to_not have_key(:channel_1)
   end
 
   it "does not delete a channel with connections remaining" do
     subject.remove(connection)
-    channels.should have_key(:channel_2)
+
+    expect(channels).to have_key(:channel_2)
   end
 
   it "handles channels not being defined" do
     subject.stubs(channels: nil)
-    subject.remove(connection)
+
+    expect {
+      subject.remove(connection)
+    }.to_not raise_error
   end
 end
 
@@ -127,6 +154,7 @@ describe PusherFake::Channel, ".reset" do
   it "empties the channel cache" do
     subject.factory("example")
     subject.reset
-    subject.channels.should == {}
+
+    expect(subject.channels).to eq({})
   end
 end

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

@@ -3,22 +3,30 @@ require "spec_helper"
 describe PusherFake::Configuration do
   it { should have_configuration_option(:app_id).with_default("PUSHER_APP_ID") }
   it { should have_configuration_option(:key).with_default("PUSHER_API_KEY") }
+  it { should have_configuration_option(:logger).with_default(STDOUT.to_io) }
   it { should have_configuration_option(:secret).with_default("PUSHER_API_SECRET") }
   it { should have_configuration_option(:socket_options).with_default({ host: "127.0.0.1", port: 8080 }) }
+  it { should have_configuration_option(:verbose).with_default(false) }
   it { should have_configuration_option(:web_options).with_default({ host: "127.0.0.1", port: 8081 }) }
   it { should have_configuration_option(:webhooks).with_default([]) }
 end
 
 describe PusherFake::Configuration, "#to_options" do
   it "includes the socket host as wsHost" do
-    subject.to_options.should include(wsHost: subject.socket_options[:host])
+    options = subject.to_options
+
+    expect(options).to include(wsHost: subject.socket_options[:host])
   end
 
   it "includes the socket port as wsPort" do
-    subject.to_options.should include(wsPort: subject.socket_options[:port])
+    options = subject.to_options
+
+    expect(options).to include(wsPort: subject.socket_options[:port])
   end
 
   it "supports passing custom options" do
-    subject.to_options(custom: "option").should include(custom: "option")
+    options = subject.to_options(custom: "option")
+
+    expect(options).to include(custom: "option")
   end
 end

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

@@ -7,7 +7,8 @@ describe PusherFake::Connection do
 
   it "assigns the provided socket" do
     connection = subject.new(socket)
-    connection.socket.should == socket
+
+    expect(connection.socket).to eq(socket)
   end
 end
 
@@ -24,12 +25,14 @@ describe PusherFake::Connection, "#emit" do
 
   it "sends the event to the socket as JSON" do
     subject.emit(event, data)
-    socket.should have_received(:send).with(json)
+
+    expect(socket).to have_received(:send).with(json)
   end
 
   it "sets a channel when provided" do
     subject.emit(event, data, channel)
-    socket.should have_received(:send).with(channel_json)
+
+    expect(socket).to have_received(:send).with(channel_json)
   end
 end
 
@@ -44,7 +47,8 @@ describe PusherFake::Connection, "#establish" do
 
   it "emits the connection established event with the socket ID" do
     subject.establish
-    subject.should have_received(:emit)
+
+    expect(subject).to have_received(:emit)
       .with("pusher:connection_established", socket_id: socket.object_id, activity_timeout: 120)
   end
 end
@@ -65,17 +69,20 @@ describe PusherFake::Connection, "#process, with a subscribe event" do
 
   it "parses the JSON data" do
     subject.process(json)
-    MultiJson.should have_received(:load).with(json, symbolize_keys: true)
+
+    expect(MultiJson).to have_received(:load).with(json, symbolize_keys: true)
   end
 
   it "creates a channel from the event data" do
     subject.process(json)
-    PusherFake::Channel.should have_received(:factory).with(name)
+
+    expect(PusherFake::Channel).to have_received(:factory).with(name)
   end
 
   it "attempts to add the connection to the channel" do
     subject.process(json)
-    channel.should have_received(:add).with(subject, data)
+
+    expect(channel).to have_received(:add).with(subject, data)
   end
 end
 
@@ -94,17 +101,51 @@ describe PusherFake::Connection, "#process, with an unsubscribe event" do
 
   it "parses the JSON data" do
     subject.process(json)
-    MultiJson.should have_received(:load).with(json, symbolize_keys: true)
+
+    expect(MultiJson).to have_received(:load).with(json, symbolize_keys: true)
   end
 
   it "creates a channel from the event data" do
     subject.process(json)
-    PusherFake::Channel.should have_received(:factory).with(name)
+
+    expect(PusherFake::Channel).to have_received(:factory).with(name)
   end
 
   it "removes the connection from the channel" do
     subject.process(json)
-    channel.should have_received(:remove).with(subject)
+
+    expect(channel).to have_received(:remove).with(subject)
+  end
+end
+
+describe PusherFake::Connection, "#process, with a ping event" do
+  let(:json)    { stub }
+  let(:message) { { event: "pusher:ping", data: {} } }
+
+  subject { PusherFake::Connection.new(stub) }
+
+  before do
+    MultiJson.stubs(load: message)
+    PusherFake::Channel.stubs(:factory)
+    subject.stubs(:emit)
+  end
+
+  it "parses the JSON data" do
+    subject.process(json)
+
+    expect(MultiJson).to have_received(:load).with(json, symbolize_keys: true)
+  end
+
+  it "does not create a channel" do
+    subject.process(json)
+
+    expect(PusherFake::Channel).to have_received(:factory).never
+  end
+
+  it "emits a pong event" do
+    subject.process(json)
+
+    expect(subject).to have_received(:emit).with("pusher:pong")
   end
 end
 
@@ -125,40 +166,50 @@ describe PusherFake::Connection, "#process, with a client event" do
 
   it "parses the JSON data" do
     subject.process(json)
-    MultiJson.should have_received(:load).with(json, symbolize_keys: true)
+
+    expect(MultiJson).to have_received(:load).with(json, symbolize_keys: true)
   end
 
   it "creates a channel from the event data" do
     subject.process(json)
-    PusherFake::Channel.should have_received(:factory).with(name)
+
+    expect(PusherFake::Channel).to have_received(:factory).with(name)
   end
 
   it "ensures the channel is private" do
     subject.process(json)
-    channel.should have_received(:is_a?).with(PusherFake::Channel::Private)
+
+    expect(channel).to have_received(:is_a?).with(PusherFake::Channel::Private)
   end
 
   it "checks if the connection is in the channel" do
     subject.process(json)
-    channel.should have_received(:includes?).with(subject)
+
+    expect(channel).to have_received(:includes?).with(subject)
   end
 
   it "emits the event to the channel when the connection is in the channel" do
     channel.stubs(includes?: true)
+
     subject.process(json)
-    channel.should have_received(:emit).with(event, data, socket_id: subject.socket.object_id)
+
+    expect(channel).to have_received(:emit).with(event, data, socket_id: subject.socket.object_id)
   end
 
   it "does not emit the event to the channel when the channel is not private" do
     channel.stubs(includes?: true, is_a?: false)
+
     subject.process(json)
-    channel.should have_received(:emit).never
+
+    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)
+
     subject.process(json)
-    channel.should have_received(:emit).never
+
+    expect(channel).to have_received(:emit).never
   end
 end
 
@@ -179,16 +230,19 @@ describe PusherFake::Connection, "#process, with an unknown event" do
 
   it "parses the JSON data" do
     subject.process(json)
-    MultiJson.should have_received(:load).with(json, symbolize_keys: true)
+
+    expect(MultiJson).to have_received(:load).with(json, symbolize_keys: true)
   end
 
   it "creates a channel from the event data" do
     subject.process(json)
-    PusherFake::Channel.should have_received(:factory).with(name)
+
+    expect(PusherFake::Channel).to have_received(:factory).with(name)
   end
 
   it "does not emit the event" do
     subject.process(json)
-    channel.should have_received(:emit).never
+
+    expect(channel).to have_received(:emit).never
   end
 end