pusher-fake 1.6.0 → 1.7.0

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

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 describe PusherFake::Channel::Private do
-  subject { PusherFake::Channel::Private }
+  subject { described_class }
 
   it "inherits from public channel" do
     expect(subject.ancestors).to include(PusherFake::Channel::Public)
@@ -9,14 +9,14 @@ describe PusherFake::Channel::Private do
 end
 
 describe PusherFake::Channel::Private, "#add" do
+  subject { described_class.new(name) }
+
   let(:data)           { { auth: authentication } }
   let(:name)           { "name" }
-  let(:connection)     { double(:connection, emit: nil) }
-  let(:connections)    { double(:connections, push: nil, length: 0) }
+  let(:connection)     { instance_double(PusherFake::Connection, emit: nil) }
+  let(:connections)    { instance_double(Array, push: nil, length: 0) }
   let(:authentication) { "auth" }
 
-  subject { PusherFake::Channel::Private.new(name) }
-
   before do
     allow(PusherFake::Webhook).to receive(:trigger)
     allow(subject).to receive(:connections).and_return(connections)
@@ -43,16 +43,18 @@ describe PusherFake::Channel::Private, "#add" do
 
     subject.add(connection, data)
 
-    expect(connection).to 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
+  it "triggers occupied webhook for first connection added when authorized" do
     allow(subject).to receive(:authorized?).and_return(true)
     allow(subject).to receive(:connections).and_call_original
 
     2.times { subject.add(connection, data) }
 
-    expect(PusherFake::Webhook).to have_received(:trigger).with("channel_occupied", channel: name).once
+    expect(PusherFake::Webhook).to have_received(:trigger)
+      .with("channel_occupied", channel: name).once
   end
 
   it "unsuccessfully subscribes the connection when not authorized" do
@@ -60,7 +62,8 @@ describe PusherFake::Channel::Private, "#add" do
 
     subject.add(connection, data)
 
-    expect(connection).to 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
@@ -69,19 +72,22 @@ describe PusherFake::Channel::Private, "#add" do
 
     2.times { subject.add(connection, data) }
 
-    expect(PusherFake::Webhook).to_not have_received(:trigger)
+    expect(PusherFake::Webhook).not_to have_received(:trigger)
   end
 end
 
 describe PusherFake::Channel::Private, "#authentication_for" do
-  let(:id)            { "1234" }
-  let(:name)          { "private-channel" }
-  let(:digest)        { double(:digest) }
-  let(:string)        { [id, name].join(":") }
-  let(:signature)     { "signature" }
-  let(:configuration) { double(:configuration, key: "key", secret: "secret") }
+  subject { described_class.new(name) }
 
-  subject { PusherFake::Channel::Private.new(name) }
+  let(:id)        { "1234" }
+  let(:name)      { "private-channel" }
+  let(:digest)    { instance_double(OpenSSL::Digest::SHA256) }
+  let(:string)    { [id, name].join(":") }
+  let(:signature) { "signature" }
+
+  let(:configuration) do
+    instance_double(PusherFake::Configuration, key: "key", secret: "secret")
+  end
 
   before do
     allow(PusherFake).to receive(:configuration).and_return(configuration)
@@ -103,16 +109,20 @@ describe PusherFake::Channel::Private, "#authentication_for" do
   end
 end
 
-describe PusherFake::Channel::Private, "#authentication_for, with channel data" do
-  let(:id)            { "1234" }
-  let(:name)          { "private-channel" }
-  let(:digest)        { double(:digest) }
-  let(:string)        { [id, name, channel_data].join(":") }
-  let(:signature)     { "signature" }
-  let(:channel_data)  { "{}" }
-  let(:configuration) { double(:configuration, key: "key", secret: "secret") }
+describe PusherFake::Channel::Private,
+         "#authentication_for, with channel data" do
+  subject { described_class.new(name) }
 
-  subject { PusherFake::Channel::Private.new(name) }
+  let(:id)           { "1234" }
+  let(:name)         { "private-channel" }
+  let(:digest)       { instance_double(OpenSSL::Digest::SHA256) }
+  let(:string)       { [id, name, channel_data].join(":") }
+  let(:signature)    { "signature" }
+  let(:channel_data) { "{}" }
+
+  let(:configuration) do
+    instance_double(PusherFake::Configuration, key: "key", secret: "secret")
+  end
 
   before do
     allow(PusherFake).to receive(:configuration).and_return(configuration)
@@ -135,14 +145,14 @@ describe PusherFake::Channel::Private, "#authentication_for, with channel data"
 end
 
 describe PusherFake::Channel::Private, "#authorized?" do
+  subject { described_class.new(name) }
+
   let(:data)           { { auth: authentication, channel_data: channel_data } }
   let(:name)           { "private-channel" }
-  let(:connection)     { double(:connection, id: "1") }
+  let(:connection)     { instance_double(PusherFake::Connection, id: "1") }
   let(:channel_data)   { "{}" }
   let(:authentication) { "authentication" }
 
-  subject { PusherFake::Channel::Private.new(name) }
-
   before do
     allow(subject).to receive(:authentication_for)
   end
@@ -150,7 +160,8 @@ describe PusherFake::Channel::Private, "#authorized?" do
   it "generates authentication for the connection ID" do
     subject.authorized?(connection, data)
 
-    expect(subject).to have_received(:authentication_for).with(connection.id, channel_data)
+    expect(subject).to have_received(:authentication_for)
+      .with(connection.id, channel_data)
   end
 
   it "returns true if the authentication matches" do
@@ -162,6 +173,6 @@ describe PusherFake::Channel::Private, "#authorized?" do
   it "returns false if the authentication matches" do
     allow(subject).to receive(:authentication_for).and_return("")
 
-    expect(subject).to_not be_authorized(connection, data)
+    expect(subject).not_to be_authorized(connection, data)
   end
 end

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

@@ -1,9 +1,9 @@
 require "spec_helper"
 
 describe PusherFake::Channel::Public do
-  let(:name) { "channel" }
+  subject { described_class }
 
-  subject { PusherFake::Channel::Public }
+  let(:name) { "channel" }
 
   it "assigns the provided name" do
     channel = subject.new(name)
@@ -19,12 +19,12 @@ describe PusherFake::Channel::Public do
 end
 
 describe PusherFake::Channel, "#add" do
-  let(:name)        { "name" }
-  let(:connection)  { double(:connection, emit: nil) }
-  let(:connections) { double(:connections, push: nil, length: 0) }
-
   subject { PusherFake::Channel::Public.new(name) }
 
+  let(:name)        { "name" }
+  let(:connection)  { instance_double(PusherFake::Connection, emit: nil) }
+  let(:connections) { instance_double(Array, push: nil, length: 0) }
+
   before do
     allow(PusherFake::Webhook).to receive(:trigger)
     allow(subject).to receive(:connections).and_return(connections)
@@ -39,7 +39,8 @@ describe PusherFake::Channel, "#add" do
   it "successfully subscribes the connection" do
     subject.add(connection)
 
-    expect(connection).to 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
@@ -47,20 +48,27 @@ describe PusherFake::Channel, "#add" do
 
     2.times { subject.add(connection) }
 
-    expect(PusherFake::Webhook).to have_received(:trigger).with("channel_occupied", channel: name).once
+    expect(PusherFake::Webhook).to have_received(:trigger)
+      .with("channel_occupied", channel: name).once
   end
 end
 
 describe PusherFake::Channel, "#emit" do
-  let(:data)         { double }
-  let(:name)         { "name" }
-  let(:event)        { "event" }
-  let(:connections)  { [connection_1, connection_2] }
-  let(:connection_1) { double(:connection, emit: nil, id: "1") }
-  let(:connection_2) { double(:connection, emit: nil, id: "2") }
-
   subject { PusherFake::Channel::Public.new(name) }
 
+  let(:data)        { double }
+  let(:name)        { "name" }
+  let(:event)       { "event" }
+  let(:connections) { [connection_1, connection_2] }
+
+  let(:connection_1) do
+    instance_double(PusherFake::Connection, emit: nil, id: "1")
+  end
+
+  let(:connection_2) do
+    instance_double(PusherFake::Connection, emit: nil, id: "2")
+  end
+
   before do
     allow(subject).to receive(:connections).and_return(connections)
   end
@@ -76,15 +84,15 @@ describe PusherFake::Channel, "#emit" 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_not have_received(:emit)
+    expect(connection_2).not_to have_received(:emit)
   end
 end
 
 describe PusherFake::Channel, "#includes?" do
-  let(:connection) { double }
-
   subject { PusherFake::Channel::Public.new("name") }
 
+  let(:connection) { double }
+
   it "returns true if the connection is in the channel" do
     allow(subject).to receive(:connections).and_return([connection])
 
@@ -94,41 +102,43 @@ describe PusherFake::Channel, "#includes?" do
   it "returns false if the connection is not in the channel" do
     allow(subject).to receive(:connections).and_return([])
 
-    expect(subject).to_not be_includes(connection)
+    expect(subject).not_to be_includes(connection)
   end
 end
 
 describe PusherFake::Channel, "#remove" do
+  subject { PusherFake::Channel::Public.new(name) }
+
   let(:name)         { "name" }
-  let(:connection_1) { double  }
+  let(:connection_1) { double }
   let(:connection_2) { double }
 
-  subject { PusherFake::Channel::Public.new(name) }
-
   before do
-    allow(subject).to receive(:connections).and_return([connection_1, connection_2])
     allow(PusherFake::Webhook).to receive(:trigger)
+    allow(subject).to receive(:connections)
+      .and_return([connection_1, connection_2])
   end
 
   it "removes the connection from the channel" do
     subject.remove(connection_1)
 
-    expect(subject.connections).to_not include(connection_1)
+    expect(subject.connections).not_to include(connection_1)
   end
 
   it "triggers channel vacated webhook when all connections are removed" do
     subject.remove(connection_1)
 
-    expect(PusherFake::Webhook).to_not have_received(:trigger)
+    expect(PusherFake::Webhook).not_to have_received(:trigger)
 
     subject.remove(connection_2)
 
-    expect(PusherFake::Webhook).to have_received(:trigger).with("channel_vacated", channel: name).once
+    expect(PusherFake::Webhook).to have_received(:trigger)
+      .with("channel_vacated", channel: name).once
   end
 end
 
 describe PusherFake::Channel::Public, "#subscription_data" do
-  subject { PusherFake::Channel::Public.new("name") }
+  subject { described_class.new("name") }
 
   it "returns an empty hash" do
     expect(subject.subscription_data).to eq({})

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

@@ -1,120 +1,80 @@
 require "spec_helper"
 
 describe PusherFake::Channel, ".factory" do
-  let(:name)    { "channel" }
-  let(:channel) { double }
+  shared_examples_for "a channel factory" do
+    subject { described_class }
 
-  subject { PusherFake::Channel }
+    let(:channel) { double }
 
-  before do
-    allow(PusherFake::Channel::Public).to receive(:new).and_return(channel)
-  end
+    before do
+      allow(channel_class).to receive(:new).and_return(channel)
+    end
 
-  after do
-    PusherFake::Channel.reset
-  end
+    after do
+      subject.reset
+    end
 
-  it "caches the channel" do
-    allow(PusherFake::Channel::Public).to receive(:new).and_call_original
+    it "caches the channel" do
+      allow(channel_class).to receive(:new).and_call_original
 
-    factory_1 = subject.factory(name)
-    factory_2 = subject.factory(name)
+      factory_one = subject.factory(name)
+      factory_two = subject.factory(name)
 
-    expect(factory_1).to eq(factory_2)
-  end
+      expect(factory_one).to eq(factory_two)
+    end
 
-  it "creates a public channel by name" do
-    subject.factory(name)
+    it "creates the channel by name" do
+      subject.factory(name)
 
-    expect(PusherFake::Channel::Public).to have_received(:new).with(name)
-  end
+      expect(channel_class).to have_received(:new).with(name)
+    end
 
-  it "returns the channel instance" do
-    factory = subject.factory(name)
+    it "returns the channel instance" do
+      factory = subject.factory(name)
 
-    expect(factory).to eq(channel)
+      expect(factory).to eq(channel)
+    end
   end
-end
-
-describe PusherFake::Channel, ".factory, for a private channel" do
-  let(:name)    { "private-channel" }
-  let(:channel) { double }
 
-  subject { PusherFake::Channel }
+  context "for a public channel" do
+    let(:name)          { "channel" }
+    let(:channel_class) { PusherFake::Channel::Public }
 
-  before do
-    allow(PusherFake::Channel::Private).to receive(:new).and_return(channel)
+    it_behaves_like "a channel factory"
   end
 
-  after do
-    PusherFake::Channel.reset
-  end
+  context "for a private channel" do
+    let(:name)          { "private-channel" }
+    let(:channel_class) { PusherFake::Channel::Private }
 
-  it "caches the channel" do
-    allow(PusherFake::Channel::Private).to receive(:new).and_call_original
-
-    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)
-
-    expect(PusherFake::Channel::Private).to have_received(:new).with(name)
+    it_behaves_like "a channel factory"
   end
 
-  it "returns the channel instance" do
-    factory = subject.factory(name)
+  context "for a presence channel" do
+    let(:name)          { "presence-channel" }
+    let(:channel_class) { PusherFake::Channel::Presence }
 
-    expect(factory).to eq(channel)
+    it_behaves_like "a channel factory"
   end
 end
 
-describe PusherFake::Channel, ".factory, for a presence channel" do
-  let(:name)    { "presence-channel" }
-  let(:channel) { double }
-
-  subject { PusherFake::Channel }
-
-  before do
-    allow(PusherFake::Channel::Presence).to receive(:new).and_return(channel)
-  end
-
-  after do
-    PusherFake::Channel.reset
-  end
-
-  it "caches the channel" do
-    allow(PusherFake::Channel::Presence).to receive(:new).and_call_original
-
-    factory_1 = subject.factory(name)
-    factory_2 = subject.factory(name)
-
-    expect(factory_1).to eq(factory_2)
-  end
+describe PusherFake::Channel, ".remove" do
+  subject { described_class }
 
-  it "creates a presence channel by name" do
-    subject.factory(name)
+  let(:channels)   { { channel_1: channel_1, channel_2: channel_2 } }
+  let(:connection) { double }
 
-    expect(PusherFake::Channel::Presence).to have_received(:new).with(name)
+  let(:channel_1) do
+    instance_double(PusherFake::Channel::Public,
+                    remove:      nil,
+                    connections: instance_double(Array, empty?: true))
   end
 
-  it "returns the channel instance" do
-    factory = subject.factory(name)
-
-    expect(factory).to eq(channel)
+  let(:channel_2) do
+    instance_double(PusherFake::Channel::Public,
+                    remove:      nil,
+                    connections: instance_double(Array, empty?: false))
   end
-end
-
-describe PusherFake::Channel, ".remove" do
-  let(:channels)   { { channel_1: channel_1, channel_2: channel_2 } }
-  let(:channel_1)  { double(:channel, connections: double(:array, empty?: true), remove: nil) }
-  let(:channel_2)  { double(:channel, connections: double(:array, empty?: false), remove: nil) }
-  let(:connection) { double }
-
-  subject { PusherFake::Channel }
 
   before do
     allow(subject).to receive(:channels).and_return(channels)
@@ -130,7 +90,7 @@ describe PusherFake::Channel, ".remove" do
   it "deletes a channel with no connections remaining" do
     subject.remove(connection)
 
-    expect(channels).to_not have_key(:channel_1)
+    expect(channels).not_to have_key(:channel_1)
   end
 
   it "does not delete a channel with connections remaining" do
@@ -142,14 +102,14 @@ describe PusherFake::Channel, ".remove" do
   it "handles channels not being defined" do
     allow(subject).to receive(:channels).and_return(nil)
 
-    expect {
+    expect do
       subject.remove(connection)
-    }.to_not raise_error
+    end.not_to raise_error
   end
 end
 
 describe PusherFake::Channel, ".reset" do
-  subject { PusherFake::Channel }
+  subject { described_class }
 
   it "empties the channel cache" do
     subject.factory("example")