listen 2.8.4 → 2.8.5

data/spec/lib/listen/tcp/broadcaster_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-
-require 'listen/tcp/broadcaster'
-
-describe Listen::TCP::Broadcaster do
-
-  let(:host) { '10.0.0.2' }
-  let(:port) { 4000 }
-
-  subject { described_class.new(host, port) }
-
-  let(:server) do
-    instance_double(described_class::TCPServer, close: true, accept: nil)
-  end
-
-  let(:socket) do
-    instance_double(described_class::TCPSocket, close: true, write: true)
-  end
-
-  let(:socket2) do
-    instance_double(described_class::TCPSocket, close: true, write: true)
-  end
-
-  let(:payload) { Listen::TCP::Message.new.payload }
-
-  before do
-    expect(described_class::TCPServer).to receive(:new).
-      with(host, port).and_return server
-    allow(server).to receive(:accept).and_raise('stub called')
-  end
-
-  after do
-    subject.terminate
-  end
-
-  describe '#start' do
-    it 'invokes run loop asynchronously' do
-      expect_any_instance_of(described_class).to receive(:run)
-      subject.start
-    end
-  end
-
-  describe '#finalize' do
-    before { allow(server).to receive(:accept).and_return nil }
-
-    it 'closes server' do
-      expect(server).to receive(:close)
-      subject.finalize
-    end
-  end
-
-  describe '#broadcast' do
-    context 'with active socket' do
-      before { allow(server).to receive(:accept).and_return socket, nil }
-
-      it 'should broadcast payload' do
-        expect(socket).to receive(:write).with(payload)
-        subject.run
-        subject.broadcast payload
-      end
-
-      it 'should keep socket' do
-        expect(socket).to receive(:write).twice.with(payload)
-        subject.run
-        2.times { subject.broadcast payload }
-      end
-
-      context 'with IOError' do
-        it 'should remove socket from list' do
-          allow(socket).to receive(:write).once.and_raise IOError
-          subject.run
-          2.times { subject.broadcast payload }
-        end
-      end
-
-      context 'when reset by peer' do
-        it 'should remove socket from list' do
-          allow(socket).to receive(:write).once.and_raise Errno::ECONNRESET
-          subject.run
-          2.times { subject.broadcast payload }
-        end
-      end
-
-      context 'when broken pipe' do
-        it 'should remove socket from list' do
-          allow(socket).to receive(:write).once.and_raise Errno::EPIPE
-          subject.run
-          2.times { subject.broadcast payload }
-        end
-      end
-
-      context 'with another active socket' do
-        before do
-          allow(server).to receive(:accept).and_return socket, socket2, nil
-        end
-
-        it 'should broadcast payload to both' do
-          expect(socket).to receive(:write).with(payload)
-          expect(socket2).to receive(:write).with(payload)
-          subject.run
-          subject.broadcast payload
-        end
-
-        context 'with a failure in first socket' do
-          before do
-            allow(socket).to receive(:write).once.and_raise Errno::EPIPE
-          end
-
-          it 'should still broadcast to remaining socket' do
-            expect(socket2).to receive(:write).with(payload)
-            subject.run
-            subject.broadcast payload
-          end
-
-          it 'should broadcast to only remaining socket' do
-            expect(socket2).to receive(:write).twice.with(payload)
-            subject.run
-            2.times { subject.broadcast payload }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/listen/tcp/listener_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-require 'listen/tcp/message'
-require 'listen/tcp/broadcaster'
-
-describe Listen::Listener do
-
-  let(:host) { '10.0.0.2' }
-  let(:port) { 4000 }
-
-  subject { described_class.new("#{host}:#{port}", :recipient, options) }
-  let(:options) { {} }
-  let(:registry) { instance_double(Celluloid::Registry, :[]= => true) }
-
-  let(:supervisor) do
-    instance_double(Celluloid::SupervisionGroup, add: true, pool: true)
-  end
-
-  let(:record) { instance_double(Listen::Record, terminate: true, build: true) }
-  let(:silencer) { instance_double(Listen::Silencer, configure: nil) }
-  let(:adapter) { instance_double(Listen::Adapter::Base) }
-  let(:async) { instance_double(Listen::TCP::Broadcaster, broadcast: true) }
-  let(:broadcaster) { instance_double(Listen::TCP::Broadcaster, async: async) }
-  let(:change_pool) { instance_double(Listen::Change, terminate: true) }
-  let(:change_pool_async) { instance_double('ChangePoolAsync') }
-  before do
-    allow(Celluloid::Registry).to receive(:new) { registry }
-    allow(Celluloid::SupervisionGroup).to receive(:run!) { supervisor }
-    allow(registry).to receive(:[]).with(:adapter) { adapter }
-    allow(registry).to receive(:[]).with(:record) { record }
-    allow(registry).to receive(:[]).with(:change_pool) { change_pool }
-    allow(registry).to receive(:[]).with(:broadcaster) { broadcaster }
-
-    allow(Listen::Silencer).to receive(:new) { silencer }
-  end
-
-  describe '#initialize' do
-    it 'raises on omitted target' do
-      expect do
-        described_class.new(nil, :recipient)
-      end.to raise_error ArgumentError
-    end
-  end
-
-  context 'when broadcaster' do
-    subject { described_class.new(port, :broadcaster) }
-
-    it 'does not force TCP adapter through options' do
-      expect(subject.options).not_to include(force_tcp: true)
-    end
-
-    describe '#start' do
-      before do
-        allow(subject).to receive(:_start_adapter)
-        allow(broadcaster).to receive(:start)
-      end
-
-      it 'registers broadcaster' do
-        expect(supervisor).to receive(:add).
-          with(Listen::TCP::Broadcaster, as: :broadcaster, args: [nil, port])
-        subject.start
-      end
-
-      it 'starts broadcaster' do
-        expect(broadcaster).to receive(:start)
-        subject.start
-      end
-    end
-
-    describe 'queue' do
-      before do
-        allow(broadcaster).to receive(:async).and_return async
-      end
-
-      context 'when stopped' do
-        it 'honours stopped state and does nothing' do
-          allow(subject).to receive(:supervisor) do
-            instance_double(Celluloid::SupervisionGroup, terminate: true)
-          end
-
-          subject.stop
-          subject.queue(:file, :modified, Pathname.pwd, 'foo')
-          expect(broadcaster).not_to receive(:async)
-        end
-      end
-
-      let(:dir) { Pathname.pwd }
-
-      it 'broadcasts changes asynchronously' do
-        message = Listen::TCP::Message.new(:file, :modified, dir, 'foo', {})
-        expect(async).to receive(:broadcast).with message.payload
-        subject.queue(:file, :modified, Pathname.pwd, 'foo')
-      end
-    end
-  end
-
-  context 'when recipient' do
-    subject { described_class.new(port, :recipient) }
-
-    it 'forces TCP adapter through options' do
-      expect(subject.options).to include(force_tcp: true)
-    end
-  end
-end

data/spec/lib/listen/tcp/message_spec.rb

@@ -1,138 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Listen::TCP::Message do
-
-  let(:object)  { [1, 2, { 'foo' => 'bar' }] }
-  let(:body)    { '[1,2,{"foo":"bar"}]' }
-  let(:size)    { 19 }
-  let(:payload) { "\x00\x00\x00\x13[1,2,{\"foo\":\"bar\"}]" }
-
-  describe '#initialize' do
-    it 'initializes with an object' do
-      message = described_class.new(1, 2, 3)
-      expect(message.object).to eq [1, 2, 3]
-    end
-  end
-
-  describe '#object=' do
-    subject do
-      described_class.new(object).tap do |message|
-        message.object = object
-      end
-    end
-
-    describe '#object' do
-      subject { super().object }
-      it  { is_expected.to be object }
-    end
-
-    describe '#body' do
-      subject { super().body }
-      it { is_expected.to eq body }
-    end
-
-    describe '#size' do
-      subject { super().size }
-      it { is_expected.to eq size }
-    end
-
-    describe '#payload' do
-      subject { super().payload }
-      it { is_expected.to eq payload }
-    end
-  end
-
-  describe '#payload=' do
-    subject do
-      described_class.new(object).tap do |message|
-        message.payload = payload
-      end
-    end
-
-    describe '#object' do
-      subject { super().object }
-      it { is_expected.to eq object }
-    end
-
-    describe '#body' do
-      subject { super().body }
-      it { is_expected.to eq body }
-    end
-
-    describe '#size' do
-      subject { super().size }
-      it { is_expected.to eq size }
-    end
-
-    describe '#payload' do
-      subject { super().payload }
-      it { is_expected.to be payload }
-    end
-  end
-
-  describe '.from_buffer' do
-
-    context 'when buffer is empty' do
-      it 'returns nil and leaves buffer intact' do
-        buffer = ''
-        message = described_class.from_buffer buffer
-        expect(message).to be_nil
-        expect(buffer).to eq ''
-      end
-    end
-
-    context 'when buffer has data' do
-
-      context 'with a partial packet' do
-        it 'returns nil and leaves remaining data intact' do
-          buffer = payload[0..4]
-          message = described_class.from_buffer buffer
-          expect(message).to be_nil
-          expect(buffer).to eq payload[0..4]
-        end
-      end
-
-      context 'with a full packet' do
-        it 'extracts message from buffer and depletes buffer' do
-          buffer = payload.dup
-          message = described_class.from_buffer buffer
-          expect(message).to be_a described_class
-          expect(message.object).to eq object
-          expect(buffer).to eq ''
-        end
-      end
-
-      context 'with a full and a partial packet' do
-        it 'extracts message from buffer and leaves remaining data intact' do
-          buffer = payload + payload[0..10]
-          message = described_class.from_buffer buffer
-          expect(message).to be_a described_class
-          expect(message.object).to eq object
-          expect(buffer).to eq payload[0..10]
-        end
-      end
-
-      context 'with two full packets' do
-        it 'extracts both messages from buffer and depletes buffer' do
-          buffer = payload + payload
-
-          message1 = described_class.from_buffer buffer
-          expect(message1).to be_a described_class
-          expect(message1.object).to eq object
-
-          message2 = described_class.from_buffer buffer
-          expect(message2).to be_a described_class
-          expect(message2.object).to eq object
-
-          expect(message1).not_to be message2
-          expect(buffer).to eq ''
-        end
-      end
-
-    end
-
-  end
-
-end

data/spec/lib/listen_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe Listen do
-  let(:listener) { instance_double(Listen::Listener, stop: nil) }
-
-  after do
-    Listen.stop
-  end
-
-  describe '.to' do
-    it 'initalizes listener' do
-      expect(Listen::Listener).to receive(:new).with('/path') { listener }
-      described_class.to('/path')
-    end
-
-    context 'when using :forward_to option' do
-      it 'initializes TCP-listener in broadcast-mode' do
-        expect(Listen::Listener).to receive(:new).
-          with(4000, :broadcaster, '/path', {}) { listener }
-        described_class.to('/path', forward_to: 4000)
-      end
-    end
-  end
-
-  describe '.stop' do
-    it 'stops all listeners & Celluloid' do
-      allow(Listen::Listener).to receive(:new).with('/path') { listener }
-      expect(listener).to receive(:stop)
-      described_class.to('/path')
-      Listen.stop
-
-      # TODO: running? returns internal_pool on 0.15.2
-      # (remove after Celluloid dependency is bumped)
-      buggy_method = if Celluloid.respond_to?(:internal_pool)
-                       Celluloid.running? == Celluloid.internal_pool
-                     else
-                       false
-                     end
-
-      pool = buggy_method ? Celluloid.internal_pool : Celluloid
-      expect(pool).to_not be_running
-    end
-  end
-
-  describe '.on' do
-    it 'initializes TCP-listener in recipient-mode' do
-      expect(Listen::Listener).to receive(:new).
-        with(4000, :recipient, '/path') { listener }
-      described_class.on(4000, '/path')
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,52 +0,0 @@
-require 'rubygems'
-
-require 'listen'
-require 'listen/tcp'
-
-require 'listen/internals/thread_pool'
-
-def ci?
-  ENV['CI']
-end
-
-if ci?
-  require 'coveralls'
-  Coveralls.wear!
-end
-
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  config.order = :random
-  config.filter_run focus: true
-  config.run_all_when_everything_filtered = true
-  # config.fail_fast = !ci?
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_doubled_constant_names = true
-    mocks.verify_partial_doubles = true
-  end
-end
-
-require 'rspec/retry'
-RSpec.configure do |config|
-  config.default_retry_count = ci? ? 5 : 1
-end
-
-require 'celluloid/rspec'
-Thread.abort_on_exception = true
-Celluloid.logger.level = Logger::ERROR
-
-RSpec.configuration.before(:each) do
-  Listen::Internals::ThreadPool.stop
-  Celluloid.boot
-end
-
-RSpec.configuration.after(:each) do
-  Celluloid.shutdown
-  Listen::Internals::ThreadPool.stop
-end