pusher-fake 4.1.0 → 4.2.0

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

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe PusherFake::Channel::Public do
-  subject { described_class }
-
-  let(:name) { "channel" }
-
-  it "assigns the provided name" do
-    channel = subject.new(name)
-
-    expect(channel.name).to eq(name)
-  end
-
-  it "creates an empty connections array" do
-    channel = subject.new(name)
-
-    expect(channel.connections).to eq([])
-  end
-end
-
-describe PusherFake::Channel, "#add" do
-  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)
-  end
-
-  it "adds the connection" do
-    subject.add(connection)
-
-    expect(connections).to have_received(:push).with(connection)
-  end
-
-  it "successfully subscribes the connection" do
-    subject.add(connection)
-
-    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
-    allow(subject).to receive(:connections).and_call_original
-
-    2.times { subject.add(connection) }
-
-    expect(PusherFake::Webhook).to have_received(:trigger)
-      .with("channel_occupied", channel: name).once
-  end
-
-  context "when a cached channel" do
-    let(:name) { "cache-name" }
-
-    before do
-      allow(subject).to receive(:connections).and_call_original
-    end
-
-    context "with a cached event" do
-      before do
-        subject.emit("example-cache-event", example: true)
-      end
-
-      it "triggers the cached event to the connection added" do
-        subject.add(connection)
-
-        expect(connection).to have_received(:emit)
-          .with("example-cache-event", { example: true }, name).once
-      end
-
-      it "does not trigger cache miss event" do
-        subject.add(connection)
-
-        expect(connection).not_to have_received(:emit)
-          .with("pusher:cache-miss", nil, name)
-      end
-
-      it "does not trigger cache miss webhook" do
-        subject.add(connection)
-
-        expect(PusherFake::Webhook).not_to have_received(:trigger)
-          .with("cache_miss", channel: name)
-      end
-    end
-
-    context "without a cached event" do
-      it "triggers cache miss event" do
-        subject.add(connection)
-
-        expect(connection).to have_received(:emit)
-          .with("pusher:cache_miss", nil, name).once
-      end
-
-      it "triggers cache miss webhook" do
-        subject.add(connection)
-
-        expect(PusherFake::Webhook).to have_received(:trigger)
-          .with("cache_miss", channel: name).once
-      end
-
-      it "does not trigger event" do
-        subject.add(connection)
-
-        expect(connection).not_to have_received(:emit)
-          .with("example-cache-event", { example: true }, name)
-      end
-    end
-  end
-end
-
-describe PusherFake::Channel, "#emit" do
-  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
-
-  it "emits the event for each connection in the channel" do
-    subject.emit(event, data)
-
-    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 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).not_to have_received(:emit)
-  end
-end
-
-describe PusherFake::Channel, "#includes?" do
-  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])
-
-    expect(subject).to be_includes(connection)
-  end
-
-  it "returns false if the connection is not in the channel" do
-    allow(subject).to receive(:connections).and_return([])
-
-    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_2) { double }
-
-  before do
-    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).not_to include(connection_1)
-  end
-
-  it "triggers channel vacated webhook when all connections are removed" do
-    subject.remove(connection_1)
-
-    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
-  end
-end
-
-describe PusherFake::Channel::Public, "#subscription_data" do
-  subject { described_class.new("name") }
-
-  it "returns an empty hash" do
-    expect(subject.subscription_data).to eq({})
-  end
-end

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

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

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

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe PusherFake::Configuration do
-  it do
-    expect(subject).to have_configuration_option(:disable_stats)
-      .with_default(true)
-  end
-
-  it do
-    expect(subject).to have_configuration_option(:key)
-      .with_default("PUSHER_API_KEY")
-  end
-
-  it do
-    expect(subject).to have_configuration_option(:logger)
-      .with_default($stdout.to_io)
-  end
-
-  it do
-    expect(subject).to have_configuration_option(:verbose)
-      .with_default(false)
-  end
-
-  it do
-    expect(subject).to have_configuration_option(:webhooks)
-      .with_default([])
-  end
-
-  it do
-    expect(subject).to have_configuration_option(:app_id)
-      .with_default("PUSHER_APP_ID")
-  end
-
-  it do
-    expect(subject).to have_configuration_option(:secret)
-      .with_default("PUSHER_API_SECRET")
-  end
-
-  it "has configuration option :socket_options" do
-    expect(subject.socket_options).to be_a(Hash)
-    expect(subject.socket_options[:host]).to eq("127.0.0.1")
-    expect(subject.socket_options[:port]).to be_a(Integer)
-  end
-
-  it "has configuration option :web_options" do
-    expect(subject.web_options).to be_a(Hash)
-    expect(subject.web_options[:host]).to eq("127.0.0.1")
-    expect(subject.web_options[:port]).to be_a(Integer)
-  end
-
-  it "defaults socket and web ports to different values" do
-    expect(subject.socket_options[:port]).not_to eq(subject.web_options[:port])
-  end
-
-  context "with StringIO as standard out" do
-    let(:io) { StringIO.new }
-
-    around do |example|
-      original = $stdout
-      $stdout  = io # rubocop:disable RSpec/ExpectOutput
-
-      example.run
-
-      $stdout = original # rubocop:disable RSpec/ExpectOutput
-    end
-
-    it "assigns standard out to the logger" do
-      subject.reset!
-
-      expect(subject.logger).to eq(io)
-    end
-  end
-end
-
-describe PusherFake::Configuration, "#app_id=" do
-  subject { described_class.new }
-
-  it "converts value to a string" do
-    subject.app_id = 1_337
-
-    expect(subject.app_id).to eq("1337")
-  end
-end
-
-describe PusherFake::Configuration, "#to_options" do
-  it "includes disable_stats as disableStats" do
-    options = subject.to_options
-
-    expect(options).to include(disableStats: subject.disable_stats)
-  end
-
-  it "includes the socket host as wsHost" do
-    options = subject.to_options
-
-    expect(options).to include(wsHost: subject.socket_options[:host])
-  end
-
-  it "includes the socket port as wsPort" do
-    options = subject.to_options
-
-    expect(options).to include(wsPort: subject.socket_options[:port])
-  end
-
-  it "includes the cluster by default" do
-    options = subject.to_options
-
-    expect(options).to include(cluster: "us-east-1")
-  end
-
-  it "disables the forceTLS option" do
-    options = subject.to_options
-
-    expect(options).to include(forceTLS: false)
-  end
-
-  it "supports passing custom options" do
-    options = subject.to_options(custom: "option")
-
-    expect(options).to include(custom: "option")
-  end
-end