listen 2.8.4 → 2.8.5

data/spec/lib/listen/adapter/linux_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-describe Listen::Adapter::Linux do
-  describe 'class' do
-    subject { described_class }
-    it { should be_local_fs }
-
-    if linux?
-      it { should be_usable }
-    else
-      it { should_not be_usable }
-    end
-  end
-
-  if linux?
-    let(:directories) { [] }
-    let(:mq) { instance_double(Listen::Listener) }
-
-    subject { described_class.new(mq: mq, directories: directories) }
-
-    # workaround: Celluloid ignores SystemExit exception messages
-    describe 'inotify limit message' do
-      let(:directories) { [Pathname.pwd] }
-
-      before do
-        require 'rb-inotify'
-        fake_worker = double(:fake_worker)
-        allow(fake_worker).to receive(:watch).and_raise(Errno::ENOSPC)
-
-        fake_notifier = double(:fake_notifier, new: fake_worker)
-        stub_const('INotify::Notifier', fake_notifier)
-      end
-
-      it 'should be shown before calling abort' do
-        expected_message = described_class.const_get('INOTIFY_LIMIT_MESSAGE')
-        expect(STDERR).to receive(:puts).with(expected_message)
-
-        # Expect RuntimeError here, for the sake of unit testing (actual
-        # handling depends on Celluloid supervisor setup, which is beyond the
-        # scope of subject tests)
-        expect { subject.start }.to raise_error RuntimeError, expected_message
-      end
-    end
-
-    describe '_callback' do
-      let(:directories) { [Pathname.pwd] }
-      before { subject.configure }
-      let(:expect_change) do
-        lambda do |change|
-          allow(mq).to receive(:_queue_raw_change).
-            with(
-              :file,
-              Pathname.pwd,
-              'path/foo.txt',
-              change: change,
-              cookie: 123)
-        end
-      end
-
-      let(:event_callback) do
-        lambda do |flags|
-          callbacks = subject.instance_variable_get(:'@callbacks')
-          callbacks.values.flatten.each do |callback|
-            callback.call double(
-              :inotify_event,
-              name: 'foo.txt',
-              watcher: double(:watcher, path: (Pathname.pwd + 'path').to_s),
-              flags: flags,
-              cookie: 123)
-          end
-        end
-      end
-
-      # TODO: get fsevent adapter working like INotify
-      unless /1|true/ =~ ENV['LISTEN_GEM_SIMULATE_FSEVENT']
-        it 'recognizes close_write as modify' do
-          expect_change.call(:modified)
-          event_callback.call([:close_write])
-        end
-
-        it 'recognizes moved_to as moved_to' do
-          expect_change.call(:moved_to)
-          event_callback.call([:moved_to])
-        end
-
-        it 'recognizes moved_from as moved_from' do
-          expect_change.call(:moved_from)
-          event_callback.call([:moved_from])
-        end
-      end
-    end
-  end
-end

data/spec/lib/listen/adapter/polling_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-include Listen
-
-describe Adapter::Polling do
-  describe 'class' do
-    subject { described_class }
-    it { should be_local_fs }
-    it { should be_usable }
-  end
-
-  subject do
-    described_class.new(options.merge(mq: mq, directories: directories))
-  end
-
-  let(:options) { {} }
-  let(:mq) { instance_double(Listener, options: options) }
-
-  describe '#start' do
-    let(:directories) { [Pathname.pwd] }
-
-    it 'notifies change on every listener directories path' do
-      expect(mq).to receive(:_queue_raw_change).
-        with(:dir, Pathname.pwd, '.', recursive: true)
-
-      t = Thread.new { subject.start }
-      sleep 0.25
-      t.kill
-      t.join
-    end
-  end
-
-  describe '#_latency' do
-    subject do
-      adapter = described_class.new(options.merge(mq: mq, directories: []))
-      adapter.options.latency
-    end
-
-    context 'with no overriding option' do
-      it { should eq 1.0 }
-    end
-
-    context 'with custom latency overriding' do
-      let(:options) { { latency: 1234 } }
-      it { should eq 1234 }
-    end
-  end
-end

data/spec/lib/listen/adapter/tcp_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-
-describe Listen::Adapter::TCP do
-
-  let(:host) { '10.0.0.2' }
-  let(:port) { 4000 }
-
-  let(:options) { { host: host, port: port } }
-
-  subject { described_class.new(options.merge(mq: listener)) }
-  let(:registry) { instance_double(Celluloid::Registry) }
-
-  let(:listener) do
-    instance_double(
-      Listen::Listener,
-      registry: registry,
-      options: {},
-      host: host,
-      port: port)
-  end
-
-  let(:socket) do
-    instance_double(described_class::TCPSocket, close: true, recv: nil)
-  end
-
-  before do
-    allow(described_class::TCPSocket).to receive(:new).and_return socket
-  end
-
-  after do
-    subject.terminate
-  end
-
-  describe '.usable?' do
-    it 'always returns true' do
-      expect(described_class).to be_usable
-    end
-  end
-
-  describe '#start' do
-    it 'initializes and exposes a socket with listener host and port' do
-      expect(described_class::TCPSocket).
-        to receive(:new).
-        with listener.host, listener.port
-
-      subject.start
-      expect(subject.socket).to be socket
-    end
-
-    it 'initializes and exposes a string buffer' do
-      subject.start
-      expect(subject.buffer).to eq ''
-    end
-
-    it 'invokes run loop' do
-      expect(subject.wrapped_object).to receive(:run)
-      subject.start
-    end
-  end
-
-  describe '#finalize' do
-    it 'clears buffer' do
-      subject.start
-      subject.finalize
-      expect(subject.buffer).to be_nil
-    end
-
-    it 'closes socket' do
-      subject.start
-      expect(subject.socket).to receive(:close)
-      subject.finalize
-      expect(subject.socket).to be_nil
-    end
-  end
-
-  describe '#run' do
-    it 'handles data from socket' do
-      allow(socket).to receive(:recv).and_return 'foo', 'bar', nil
-
-      expect_any_instance_of(described_class).
-        to receive(:handle_data).with('foo')
-
-      expect_any_instance_of(described_class).
-        to receive(:handle_data).with('bar')
-
-      subject.start
-
-      # quick workaround because run is called asynchronously
-      sleep 0.5
-    end
-  end
-
-  describe '#handle_data' do
-    it 'buffers data' do
-      subject.start
-      subject.handle_data 'foo'
-      subject.handle_data 'bar'
-      expect(subject.buffer).to eq 'foobar'
-    end
-
-    it 'handles messages accordingly' do
-      message = Listen::TCP::Message.new
-
-      allow(Listen::TCP::Message).to receive(:from_buffer).
-        and_return message, nil
-
-      expect(Listen::TCP::Message).to receive(:from_buffer).with 'foo'
-      expect(subject.wrapped_object).to receive(:handle_message).with message
-
-      subject.start
-      subject.handle_data 'foo'
-    end
-  end
-
-  describe '#handle_message' do
-    let(:dir) { Pathname.pwd }
-    it 'notifies listener of path changes' do
-      message = Listen::TCP::Message.new('file', 'modified', dir, 'foo', {})
-
-      expect(subject.wrapped_object).
-        to receive(:_queue_change).with :file, dir, 'foo', change: :modified
-
-      subject.handle_message message
-    end
-  end
-
-  specify { expect(described_class).to_not be_local_fs }
-
-end

data/spec/lib/listen/adapter/windows_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe Listen::Adapter::Windows do
-  describe 'class' do
-    subject { described_class }
-    it { should be_local_fs }
-
-    if windows?
-      it { should be_usable }
-    else
-      it { should_not be_usable }
-    end
-  end
-end

data/spec/lib/listen/adapter_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-describe Listen::Adapter do
-
-  let(:listener) { instance_double(Listen::Listener, options: {}) }
-  before do
-    allow(Listen::Adapter::BSD).to receive(:usable?) { false }
-    allow(Listen::Adapter::Darwin).to receive(:usable?) { false }
-    allow(Listen::Adapter::Linux).to receive(:usable?) { false }
-    allow(Listen::Adapter::Windows).to receive(:usable?) { false }
-  end
-
-  describe '.select' do
-    it 'returns TCP adapter when requested' do
-      klass = Listen::Adapter.select(force_tcp: true)
-      expect(klass).to eq Listen::Adapter::TCP
-    end
-
-    it 'returns Polling adapter if forced' do
-      klass = Listen::Adapter.select(force_polling: true)
-      expect(klass).to eq Listen::Adapter::Polling
-    end
-
-    it 'returns BSD adapter when usable' do
-      allow(Listen::Adapter::BSD).to receive(:usable?) { true }
-      klass = Listen::Adapter.select
-      expect(klass).to eq Listen::Adapter::BSD
-    end
-
-    it 'returns Darwin adapter when usable' do
-      allow(Listen::Adapter::Darwin).to receive(:usable?) { true }
-      klass = Listen::Adapter.select
-      expect(klass).to eq Listen::Adapter::Darwin
-    end
-
-    it 'returns Linux adapter when usable' do
-      allow(Listen::Adapter::Linux).to receive(:usable?) { true }
-      klass = Listen::Adapter.select
-      expect(klass).to eq Listen::Adapter::Linux
-    end
-
-    it 'returns Windows adapter when usable' do
-      allow(Listen::Adapter::Windows).to receive(:usable?) { true }
-      klass = Listen::Adapter.select
-      expect(klass).to eq Listen::Adapter::Windows
-    end
-
-    context 'no usable adapters' do
-      before { allow(Kernel).to receive(:warn) }
-
-      it 'returns Polling adapter' do
-        klass = Listen::Adapter.select(force_polling: true)
-        expect(klass).to eq Listen::Adapter::Polling
-      end
-
-      it 'warns polling fallback with default message' do
-        msg = described_class::POLLING_FALLBACK_MESSAGE
-        expect(Kernel).to receive(:warn).with("[Listen warning]:\n  #{msg}")
-        Listen::Adapter.select
-      end
-
-      it "doesn't warn if polling_fallback_message is false" do
-        expect(Kernel).to_not receive(:warn)
-        Listen::Adapter.select(polling_fallback_message: false)
-      end
-
-      it 'warns polling fallback with custom message if set' do
-        expected_msg = "[Listen warning]:\n  custom fallback message"
-        expect(Kernel).to receive(:warn).with(expected_msg)
-        msg = 'custom fallback message'
-        Listen::Adapter.select(polling_fallback_message: msg)
-      end
-    end
-  end
-end

data/spec/lib/listen/change_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-describe Listen::Change do
-  let(:subject) { Listen::Change.new(listener) }
-  let(:listener) { instance_double(Listen::Listener, options: {}) }
-  let(:record) { instance_double(Listen::Record) }
-  let(:full_file_path) { instance_double(Pathname, to_s: '/dir/file.rb') }
-  let(:full_dir_path) { instance_double(Pathname, to_s: '/dir') }
-  let(:dir) { instance_double(Pathname) }
-
-  before do
-    allow(listener).to receive(:sync).with(:record) { record }
-    allow(listener).to receive(:async).with(:change_pool) { subject }
-    allow(dir).to receive(:+).with('file.rb') { full_file_path }
-    allow(dir).to receive(:+).with('dir1') { full_dir_path }
-  end
-
-  describe '#change' do
-    let(:silencer) { instance_double(Listen::Silencer, silenced?: false) }
-    before { allow(listener).to receive(:silencer) { silencer } }
-
-    context 'with build options' do
-      it 'calls still_building! on record' do
-        allow(listener).to receive(:queue)
-        allow(record).to receive(:async) { async_record }
-        allow(Listen::File).to receive(:change)
-        subject.change(:file, dir, 'file.rb', build: true)
-      end
-    end
-
-    context 'file' do
-      context 'with known change' do
-        it 'notifies change directly to listener' do
-          expect(listener).to receive(:queue).
-            with(:file, :modified, dir, 'file.rb', {})
-
-          subject.change(:file, dir, 'file.rb', change: :modified)
-        end
-
-        it "doesn't notify to listener if path is silenced" do
-          expect(silencer).to receive(:silenced?).and_return(true)
-          expect(listener).to_not receive(:queue)
-          subject.change(:file, dir, 'file.rb', change: :modified)
-        end
-      end
-
-      context 'with unknown change' do
-
-        it 'calls Listen::File#change' do
-          expect(Listen::File).to receive(:change).with(record, dir, 'file.rb')
-          subject.change(:file, dir, 'file.rb')
-        end
-
-        it "doesn't call Listen::File#change if path is silenced" do
-          expect(silencer).to receive(:silenced?).
-            with(Pathname('file.rb'), :file).and_return(true)
-
-          expect(Listen::File).to_not receive(:change)
-          subject.change(:file, dir, 'file.rb')
-        end
-
-        context 'that returns a change' do
-          before { allow(Listen::File).to receive(:change) { :modified } }
-
-          context 'listener listen' do
-            it 'notifies change to listener' do
-              expect(listener).to receive(:queue).
-                with(:file, :modified, dir, 'file.rb')
-
-              subject.change(:file, dir, 'file.rb')
-            end
-
-            context 'silence option' do
-              it 'notifies change to listener' do
-                expect(listener).to_not receive(:queue)
-                subject.change(:file, dir, 'file.rb', silence: true)
-              end
-            end
-          end
-        end
-
-        context 'that returns no change' do
-          before { allow(Listen::File).to receive(:change) { nil } }
-
-          it "doesn't notifies no change" do
-            expect(listener).to_not receive(:queue)
-            subject.change(:file, dir, 'file.rb')
-          end
-        end
-      end
-    end
-
-    context 'directory' do
-      let(:dir_options) { { recursive: true } }
-
-      it 'calls Listen::Directory#new' do
-        expect(Listen::Directory).to receive(:scan).
-          with(subject, record, dir, 'dir1', dir_options)
-
-        subject.change(:dir, dir, 'dir1', dir_options)
-      end
-    end
-  end
-end