listen 2.8.4 → 2.8.5

data/spec/acceptance/listen_spec.rb

@@ -1,230 +0,0 @@
-# encoding: UTF-8
-require 'spec_helper'
-
-describe 'Listen' do
-  let(:base_options) { { wait_for_delay: 0.1, latency: 0.1 } }
-  let(:polling_options) { {} }
-  let(:options) { {} }
-  let(:all_options) { base_options.merge(polling_options).merge(options) }
-
-  let(:wrapper) { setup_listener(all_options, :track_changes) }
-  before { wrapper.listener.start }
-  after { wrapper.listener.stop }
-
-  subject { wrapper }
-
-  context 'with one listen dir' do
-    let(:paths) { Pathname.new(Dir.pwd) }
-    around { |example| fixtures { example.run } }
-
-    context 'with change block raising' do
-      let(:callback) { ->(_, _, _) { fail 'foo' } }
-      let(:wrapper) { setup_listener(all_options, callback) }
-
-      it 'warns the backtrace' do
-        expect(Kernel).to receive(:warn).
-          with(/exception while processing events: foo .*Backtrace:/)
-        wrapper.listen { touch 'file.rb' }
-      end
-    end
-
-    [false, true].each do |polling|
-      context "force_polling option to #{polling}" do
-        let(:polling_options) { { force_polling: polling } }
-
-        context 'with default ignore options' do
-          context 'with nothing in listen dir' do
-
-            it { is_expected.to process_addition_of('file.rb') }
-            it { is_expected.to process_addition_of('.hidden') }
-
-            it 'listens to multiple files addition' do
-              result = wrapper.listen do
-                change_fs(:added, 'file1.rb')
-                change_fs(:added, 'file2.rb')
-              end
-
-              expect(result).to eq(modified: [],
-                                   added: %w(file1.rb file2.rb),
-                                   removed: [])
-            end
-
-            it 'listens to file moved inside' do
-              touch '../file.rb'
-              expect(wrapper.listen do
-                mv '../file.rb', 'file.rb'
-              end).to eq(modified: [], added: ['file.rb'], removed: [])
-            end
-          end
-
-          context 'existing file.rb in listen dir' do
-            around do |example|
-              change_fs(:added, 'file.rb')
-              example.run
-            end
-
-            it { is_expected.to process_modification_of('file.rb') }
-            it { is_expected.to process_removal_of('file.rb') }
-
-            it 'listens to file.rb moved out' do
-              expect(wrapper.listen do
-                mv 'file.rb', '../file.rb'
-              end).to eq(modified: [], added: [], removed: ['file.rb'])
-            end
-
-            it 'listens to file mode change' do
-              prev_mode = File.stat('file.rb').mode
-
-              result = wrapper.listen do
-                windows? ? `attrib +r file.rb` : chmod(0444, 'file.rb')
-              end
-
-              new_mode = File.stat('file.rb').mode
-              no_event = result[:modified].empty? && prev_mode == new_mode
-
-              # Check if chmod actually works or an attrib event happens,
-              # or expect nothing otherwise
-              #
-              # (e.g. fails for polling+vfat on Linux, but works with
-              # INotify+vfat because you get an event regardless if mode
-              # actually changes)
-              #
-              files = no_event ? [] : ['file.rb']
-
-              expect(result).to eq(modified: files, added: [], removed: [])
-            end
-          end
-
-          context 'hidden file in listen dir' do
-            around do |example|
-              change_fs(:added, '.hidden')
-              example.run
-            end
-
-            it { is_expected.to process_modification_of('.hidden') }
-          end
-
-          context 'dir in listen dir' do
-            around do |example|
-              mkdir_p 'dir'
-              example.run
-            end
-
-            it { is_expected.to process_addition_of('dir/file.rb') }
-          end
-
-          context 'dir with file in listen dir' do
-            around do |example|
-              mkdir_p 'dir'
-              touch 'dir/file.rb'
-              example.run
-            end
-
-            it 'listens to file move' do
-              expected = { modified: [],
-                           added: %w(file.rb),
-                           removed: %w(dir/file.rb)
-              }
-
-              expect(wrapper.listen do
-                mv 'dir/file.rb', 'file.rb'
-              end).to eq expected
-            end
-          end
-
-          context 'two dirs with files in listen dir' do
-            around do |example|
-              mkdir_p 'dir1'
-              touch 'dir1/file1.rb'
-              mkdir_p 'dir2'
-              touch 'dir2/file2.rb'
-              example.run
-            end
-
-            it 'listens to multiple file moves' do
-              expected = {
-                modified: [],
-                added: ['dir1/file2.rb', 'dir2/file1.rb'],
-                removed: ['dir1/file1.rb', 'dir2/file2.rb']
-              }
-
-              expect(wrapper.listen do
-                mv 'dir1/file1.rb', 'dir2/file1.rb'
-                mv 'dir2/file2.rb', 'dir1/file2.rb'
-              end).to eq expected
-            end
-
-            it 'listens to dir move' do
-              expected = { modified: [],
-                           added: ['dir2/dir1/file1.rb'],
-                           removed: ['dir1/file1.rb'] }
-
-              expect(wrapper.listen do
-                mv 'dir1', 'dir2/'
-              end).to eq expected
-            end
-          end
-
-          context 'with .bundle dir ignored by default' do
-            around do |example|
-              mkdir_p '.bundle'
-              example.run
-            end
-
-            it { is_expected.not_to process_addition_of('.bundle/file.rb') }
-          end
-        end
-
-        context 'when :ignore is *ignored_dir*' do
-          context 'ignored dir with file in listen dir' do
-            let(:options) { { ignore: /ignored_dir/ } }
-
-            around do |example|
-              mkdir_p 'ignored_dir'
-              example.run
-            end
-
-            it { is_expected.not_to process_addition_of('ignored_dir/file.rb') }
-          end
-
-          context 'when :only is *.rb' do
-            let(:options) { { only: /\.rb$/ } }
-
-            it { is_expected.to process_addition_of('file.rb') }
-            it { is_expected.not_to process_addition_of('file.txt') }
-          end
-
-          context 'when :ignore is bar.rb' do
-            context 'when :only is *.rb' do
-              let(:options) { { ignore: /bar\.rb$/, only: /\.rb$/ } }
-
-              it { is_expected.to process_addition_of('file.rb') }
-              it { is_expected.not_to process_addition_of('file.txt') }
-              it { is_expected.not_to process_addition_of('bar.rb') }
-            end
-          end
-
-          context 'when default ignore is *.rb' do
-            let(:options) { { ignore: /\.rb$/ } }
-
-            it { is_expected.not_to process_addition_of('file.rb') }
-
-            context 'with #ignore on *.txt mask' do
-              before { wrapper.listener.ignore(/\.txt/) }
-
-              it { is_expected.not_to process_addition_of('file.rb') }
-              it { is_expected.not_to process_addition_of('file.txt') }
-            end
-
-            context 'with #ignore! on *.txt mask' do
-              before { wrapper.listener.ignore!(/\.txt/) }
-
-              it { is_expected.to process_addition_of('file.rb') }
-              it { is_expected.not_to process_addition_of('file.txt') }
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/acceptance/tcp_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper'
-
-describe Listen::Listener do
-
-  let(:port) { 4000 }
-  let(:broadcast_options) { { forward_to: port } }
-  let(:paths) { Pathname.new(Dir.pwd) }
-
-  around do |example|
-    fixtures { example.run }
-    Listen.stop
-  end
-
-  modes = if !windows? || Celluloid::VERSION > '0.15.2'
-            [:recipient, :broadcaster]
-          else
-            [:broadcaster]
-          end
-
-  modes.each do |mode|
-    context "when #{mode}" do
-      if mode == :broadcaster
-        subject { setup_listener(broadcast_options, :track_changes) }
-        before { subject.listener.start }
-        after { subject.listener.stop }
-      else
-        subject { setup_recipient(port, :track_changes) }
-        let(:broadcaster) { setup_listener(broadcast_options) }
-
-        before do
-          broadcaster.listener.start
-          # Travis on OSX is too slow
-          subject.lag = 1.2
-          subject.listener.start
-        end
-        after do
-          broadcaster.listener.stop
-          subject.listener.stop
-        end
-      end
-
-      it { should process_addition_of('file.rb') }
-
-      context 'when paused' do
-        before { subject.listener.pause }
-
-        context 'with no queued changes' do
-          it { should_not process_addition_of('file.rb') }
-
-          context 'when unpaused' do
-            before { subject.listener.unpause }
-            it { should process_addition_of('file.rb') }
-          end
-        end
-
-        context 'with queued addition' do
-          before { change_fs(:added, 'file.rb') }
-          it { should_not process_modification_of('file.rb') }
-
-          context 'when unpaused' do
-            before { subject.listener.unpause }
-            it { should process_queued_addition_of('file.rb') }
-            it { should process_modification_of('file.rb') }
-          end
-        end
-
-        context 'with queued modification' do
-          before do
-            change_fs(:added, 'file.rb')
-            change_fs(:modified, 'file.rb')
-          end
-
-          it { should_not process_queued_addition_of('file.rb') }
-          it { should_not process_queued_modification_of('file.rb') }
-
-          context 'when unpaused' do
-            before { subject.listener.unpause }
-            it { should process_queued_addition_of('file.rb') }
-
-            # NOTE: when adapter is 'local_fs?', the change optimizer
-            # (_squash_changes) reduces the "add+mod" into a single "add"
-            if mode == :broadcaster
-              # "optimizing" on local fs (broadcaster) will remove
-              # :modified from queue
-              it { should_not process_queued_modification_of('file.rb') }
-            else
-              # optimization skipped, because it's TCP, so we'll have both
-              # :modified and :added events for same file
-              it { should process_queued_modification_of('file.rb') }
-            end
-
-            it { should process_modification_of('file.rb') }
-          end
-        end
-      end
-
-      context 'when stopped' do
-        before { subject.listener.stop }
-
-        context 'with no queued changes' do
-          it { should_not process_addition_of('file.rb') }
-
-          context 'when started' do
-            before { subject.listener.start }
-            it { should process_addition_of('file.rb') }
-          end
-        end
-
-        context 'with queued addition' do
-          before { change_fs(:added, 'file.rb') }
-          it { should_not process_modification_of('file.rb') }
-
-          context 'when started' do
-            before { subject.listener.start }
-            it { should_not process_queued_addition_of('file.rb') }
-            it { should process_modification_of('file.rb') }
-          end
-        end
-
-        context 'with queued modification' do
-          before do
-            change_fs(:added, 'file.rb')
-            change_fs(:modified, 'file.rb')
-          end
-
-          it { should_not process_queued_addition_of('file.rb') }
-          it { should_not process_queued_modification_of('file.rb') }
-
-          context 'when started' do
-            before { subject.listener.start }
-            it { should_not process_queued_addition_of('file.rb') }
-            it { should_not process_queued_modification_of('file.rb') }
-            it { should process_modification_of('file.rb') }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-include Listen
-
-describe Adapter::Base do
-
-  class FakeAdapter < described_class
-    def initialize(*args)
-      super(*args)
-    end
-  end
-
-  subject { FakeAdapter.new(mq: mq, directories: []) }
-
-  let(:mq) { instance_double(Listener) }
-
-  describe '#_notify_change' do
-    let(:dir) { Pathname.pwd }
-
-    context 'listener is listening or paused' do
-      let(:worker) { instance_double(Change) }
-
-      it 'calls change on change_pool asynchronously' do
-        expect(mq).to receive(:_queue_raw_change).
-          with(:dir, dir, 'path', recursive: true)
-
-        subject.send(:_queue_change, :dir, dir, 'path', recursive: true)
-      end
-    end
-  end
-end

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

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

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

@@ -1,145 +0,0 @@
-require 'spec_helper'
-
-# This is just so stubs work
-require 'rb-fsevent'
-
-require 'listen/adapter/darwin'
-
-include Listen
-
-describe Adapter::Darwin do
-  describe 'class' do
-    subject { described_class }
-    it { should be_local_fs }
-
-    if darwin?
-      it { should be_usable }
-    else
-      it { should_not be_usable }
-    end
-  end
-
-  let(:options) { {} }
-  let(:mq) { instance_double(Listener, options: options) }
-
-  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 0.1 }
-    end
-
-    context 'with custom latency overriding' do
-      let(:options) { { latency: 1234 } }
-      it { should eq 1234 }
-    end
-  end
-
-  describe 'multiple dirs' do
-    subject do
-      dirs = config.keys.map { |p| Pathname(p.to_s) }
-      described_class.new(directories: dirs)
-    end
-
-    let(:foo1) { double('foo1') }
-    let(:foo2) { double('foo2') }
-    let(:foo3) { double('foo3') }
-
-    before do
-      allow(FSEvent).to receive(:new).and_return(*config.values, nil)
-      config.each do |dir, obj|
-        allow(obj).to receive(:watch).with(dir.to_s, latency: 0.1)
-      end
-      subject.configure
-    end
-
-    describe 'configuration' do
-      context 'with 1 directory' do
-        let(:config) { { dir1: foo1 } }
-
-        it 'configures directory' do
-          expect(foo1).to have_received(:watch).with('dir1', latency: 0.1)
-        end
-      end
-
-      context 'with 2 directories' do
-        let(:config) { { dir1: foo1, dir2: foo2 } }
-
-        it 'configures directories' do
-          expect(foo1).to have_received(:watch).with('dir1', latency: 0.1)
-          expect(foo2).to have_received(:watch).with('dir2', latency: 0.1)
-        end
-      end
-
-      context 'with 3 directories' do
-        let(:config) { { dir1: foo1, dir2: foo2, dir3: foo3 } }
-
-        it 'configures directories' do
-          expect(foo1).to have_received(:watch).with('dir1', latency: 0.1)
-          expect(foo2).to have_received(:watch).with('dir2', latency: 0.1)
-          expect(foo3).to have_received(:watch).with('dir3', latency: 0.1)
-        end
-      end
-    end
-
-    describe 'running threads' do
-      let(:running) { [] }
-
-      before do
-        started = Queue.new
-        threads = Queue.new
-        left = Queue.new
-
-        # NOTE: Travis has a hard time creating threads on OSX
-        thread_start_overhead = 3
-        max_test_time = 3 * thread_start_overhead
-        block_time = max_test_time + thread_start_overhead
-
-        config.each do |name, obj|
-          left << name # anything, we're just counting
-          allow(obj).to receive(:run).once do
-            threads << Thread.current
-            started << name
-            left.pop
-            sleep block_time
-          end
-        end
-
-        Timeout.timeout(max_test_time) do
-          subject.start
-          running << started.pop until left.empty?
-        end
-
-        running << started.pop until started.empty?
-
-        killed = Queue.new
-        killed << threads.pop.kill until threads.empty?
-        killed.pop.join until killed.empty?
-      end
-
-      context 'with 1 directory' do
-        let(:config) { { dir1: foo1 } }
-        it 'runs all the workers without blocking' do
-          expect(running.sort).to eq(config.keys)
-        end
-      end
-
-      context 'with 2 directories' do
-        let(:config) { { dir1: foo1, dir2: foo2 } }
-        it 'runs all the workers without blocking' do
-          expect(running.sort).to eq(config.keys)
-        end
-      end
-
-      context 'with 3 directories' do
-        let(:config) { { dir1: foo1, dir2: foo2, dir3: foo3 } }
-        it 'runs all the workers without blocking' do
-          expect(running.sort).to eq(config.keys)
-        end
-      end
-    end
-  end
-end