listen 2.8.4 → 2.8.5

data/spec/lib/listen/directory_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-
-include Listen
-
-describe Directory do
-  let(:dir) { double(:dir) }
-  let(:file) { double(:file, directory?: false) }
-  let(:file2) { double(:file2, directory?: false) }
-  let(:subdir) { double(:subdir, directory?: true) }
-
-  let(:queue) { instance_double(Change, change: nil) }
-
-  let(:async_record) do
-    instance_double(Record, add_dir: true, unset_path: true)
-  end
-
-  let(:record) do
-    instance_double(Record, async: async_record, dir_entries: record_entries)
-  end
-
-  before do
-    allow(dir).to receive(:+).with('.') { dir }
-    allow(dir).to receive(:+).with('file.rb') { file }
-    allow(dir).to receive(:+).with('subdir') { subdir }
-
-    allow(file).to receive(:relative_path_from).with(dir) { 'file.rb' }
-    allow(file2).to receive(:relative_path_from).with(dir) { 'file2.rb' }
-    allow(subdir).to receive(:relative_path_from).with(dir) { 'subdir' }
-  end
-
-  context '#scan with recursive off' do
-    let(:options) { { recursive: false } }
-
-    context 'with file & subdir in record' do
-      let(:record_entries) do
-        { 'file.rb' => { mtime: 1.1 }, 'subdir' => {} }
-      end
-
-      context 'with empty dir' do
-        before { allow(dir).to receive(:children) { [] } }
-
-        it 'sets record dir path' do
-          expect(async_record).to receive(:add_dir).with(dir, '.')
-          described_class.scan(queue, record, dir, '.', options)
-        end
-
-        it "queues changes for file path and dir that doesn't exist" do
-          expect(queue).to receive(:change).with(:file, dir, 'file.rb')
-
-          expect(queue).to receive(:change).
-            with(:dir, dir, 'subdir', recursive: false)
-
-          described_class.scan(queue, record, dir, '.', options)
-        end
-      end
-
-      context 'with only file2.rb in dir' do
-        before { allow(dir).to receive(:children) { [file2] } }
-
-        it 'notices file & file2 and no longer existing dir' do
-          expect(queue).to receive(:change).with(:file, dir, 'file.rb')
-          expect(queue).to receive(:change).with(:file, dir, 'file2.rb')
-
-          expect(queue).to receive(:change).
-            with(:dir, dir, 'subdir', recursive: false)
-
-          described_class.scan(queue, record, dir, '.', options)
-        end
-      end
-    end
-
-    context 'with empty record' do
-      let(:record_entries) { {} }
-
-      context 'with non-existing dir path' do
-        before { allow(dir).to receive(:children) { fail Errno::ENOENT } }
-
-        it 'reports no changes' do
-          expect(queue).to_not receive(:change)
-          described_class.scan(queue, record, dir, '.', options)
-        end
-
-        it 'unsets record dir path' do
-          expect(async_record).to receive(:unset_path).with(dir, '.')
-          described_class.scan(queue, record, dir, '.', options)
-        end
-      end
-
-      context 'with file.rb in dir' do
-        before { allow(dir).to receive(:children) { [file] } }
-
-        it 'queues changes for file & file2 paths' do
-          expect(queue).to receive(:change).with(:file, dir, 'file.rb')
-          expect(queue).to_not receive(:change).with(:file, dir, 'file2.rb')
-
-          expect(queue).to_not receive(:change).
-            with(:dir, dir, 'subdir', recursive: false)
-
-          described_class.scan(queue, record, dir, '.', options)
-        end
-      end
-    end
-  end
-
-  context '#scan with recursive on' do
-    let(:options) { { recursive: true } }
-
-    context 'with file.rb & subdir in record' do
-      let(:record_entries) do
-        { 'file.rb' => { mtime: 1.1 }, 'subdir' => {} }
-      end
-
-      context 'with empty dir' do
-        before do
-          allow(dir).to receive(:children) { [] }
-        end
-
-        it 'queues changes for file & subdir path' do
-          expect(queue).to receive(:change).with(:file, dir, 'file.rb')
-
-          expect(queue).to receive(:change).
-            with(:dir, dir, 'subdir', recursive: true)
-
-          described_class.scan(queue, record, dir, '.', options)
-        end
-      end
-
-      context 'with subdir2 path present in dir' do
-        let(:subdir2) { double(:subdir2, directory?: true, children: []) }
-
-        before do
-          allow(dir).to receive(:children) { [subdir2] }
-          allow(subdir2).to receive(:relative_path_from).with(dir) { 'subdir2' }
-        end
-
-        it 'queues changes for file, file2 & subdir paths' do
-          expect(queue).to receive(:change).with(:file, dir, 'file.rb')
-
-          expect(queue).to receive(:change).
-            with(:dir, dir, 'subdir', recursive: true)
-
-          expect(queue).to receive(:change).
-            with(:dir, dir, 'subdir2', recursive: true)
-
-          described_class.scan(queue, record, dir, '.', options)
-        end
-      end
-    end
-
-    context 'with empty record' do
-      let(:record_entries) { {} }
-
-      context 'with non-existing dir' do
-        before do
-          allow(dir).to receive(:children) { fail Errno::ENOENT }
-        end
-
-        it 'reports no changes' do
-          expect(queue).to_not receive(:change)
-          described_class.scan(queue, record, dir, '.', options)
-        end
-      end
-
-      context 'with subdir present in dir' do
-
-        before do
-          allow(dir).to receive(:children) { [subdir] }
-          allow(subdir).to receive(:children) { [] }
-        end
-
-        it 'queues changes for subdir' do
-          expect(queue).to receive(:change).
-            with(:dir, dir, 'subdir', recursive: true)
-
-          described_class.scan(queue, record, dir, '.', options)
-        end
-      end
-    end
-  end
-end

data/spec/lib/listen/file_spec.rb

@@ -1,252 +0,0 @@
-require 'spec_helper'
-
-describe Listen::File do
-  let(:async_record) do
-    instance_double(
-      Listen::Record,
-      add_dir: true,
-      update_file: true,
-      unset_path: true
-    )
-  end
-
-  let(:record) do
-    instance_double(
-      Listen::Record,
-      async: async_record,
-      file_data: record_data
-    )
-  end
-
-  let(:path) { Pathname.pwd }
-  let(:subject) { described_class.change(record, path, 'file.rb') }
-
-  around { |example| fixtures { example.run } }
-
-  before { allow(::File).to receive(:lstat) { fail 'Not stubbed!' } }
-
-  describe '#change' do
-    let(:expected_data) do
-      { mtime: kind_of(Float), mode: kind_of(Integer) }
-    end
-
-    context 'with file record' do
-      let(:record_mtime) { nil }
-      let(:record_md5) { nil }
-      let(:record_mode) { nil }
-
-      let(:record_data) do
-        { mtime: record_mtime, md5: record_md5, mode: record_mode }
-      end
-
-      context 'with non-existing file' do
-        before { allow(::File).to receive(:lstat) { fail Errno::ENOENT } }
-
-        it { should be :removed }
-
-        it 'sets path in record' do
-          expect(async_record).to receive(:unset_path).with(path, 'file.rb')
-          subject
-        end
-      end
-
-      context 'with existing file' do
-        let(:stat_mtime) { Time.now.to_f - 1234.567 }
-        let(:stat_ctime) { Time.now.to_f - 1234.567 }
-        let(:stat_atime) { Time.now.to_f - 1234.567 }
-        let(:stat_mode) { 0640 }
-        let(:md5) { fail 'stub me (md5)' }
-
-        let(:stat) do
-          instance_double(
-            File::Stat,
-            mtime: stat_mtime,
-            atime: stat_atime,
-            ctime: stat_ctime,
-            mode: stat_mode
-          )
-        end
-
-        before do
-          allow(::File).to receive(:lstat) { stat }
-          allow(Digest::MD5).to receive(:file) { double(:md5, digest: md5) }
-        end
-
-        context 'with different mode in record' do
-          let(:record_mode) { 0722 }
-
-          it { should be :modified }
-
-          it 'sets path in record with expected data' do
-            expect(async_record).to receive(:update_file).
-              with(path, 'file.rb', expected_data)
-            subject
-          end
-        end
-
-        context 'with same mode in record' do
-          let(:record_mode) { stat_mode }
-
-          # e.g. file was overwritten by earlier copy
-          context 'with earlier mtime than in record' do
-            let(:record_mtime) { stat_mtime.to_f - 123.45 }
-
-            it { should be :modified }
-
-            it 'sets path in record with expected data' do
-              expect(async_record).to receive(:update_file).
-                with(path, 'file.rb', expected_data)
-              subject
-            end
-          end
-
-          context 'with later mtime than in record' do
-            let(:record_mtime) { stat_mtime.to_f + 123.45 }
-
-            it { should be :modified }
-
-            it 'sets path in record with expected data' do
-              expect(async_record).to receive(:update_file).
-                with(path, 'file.rb', expected_data)
-              subject
-            end
-          end
-
-          context 'with indentical mtime in record' do
-            let(:record_mtime) { stat_mtime.to_f }
-
-            context 'with accurate stat times' do
-              let(:stat_mtime) { Time.at(1_401_235_714.123) }
-              let(:stat_atime) { Time.at(1_401_235_714.123) }
-              let(:stat_ctime) { Time.at(1_401_235_714.123) }
-              let(:record_mtime) { stat_mtime.to_f }
-              it { should be_nil }
-            end
-
-            context 'with inaccurate stat times' do
-              let(:stat_mtime) { Time.at(1_401_235_714.0) }
-              let(:stat_atime) { Time.at(1_401_235_714.0) }
-              let(:stat_ctime) { Time.at(1_401_235_714.0) }
-
-              let(:record_mtime) { stat_mtime.to_f }
-
-              context 'with real mtime barely not within last second' do
-                before { allow(Time).to receive(:now) { now } }
-
-                # NOTE: if real mtime is ???14.99, the
-                # saved mtime is ???14.0
-                let(:now) { Time.at(1_401_235_716.00) }
-                it { should be_nil }
-              end
-
-              context 'with real mtime barely within last second' do
-                # NOTE: real mtime is in range (???14.0 .. ???14.999),
-                # so saved mtime at ???14.0 means it could be
-                # ???14.999, so ???15.999 could still be within 1 second
-                # range
-                let(:now) { Time.at(1_401_235_715.999999) }
-
-                before { allow(Time).to receive(:now) { now } }
-
-                context 'without available md5' do
-                  let(:md5) { fail Errno::ENOENT }
-
-                  # Treat it as a removed file, because chances are ...
-                  # whatever is listening for changes won't be able to deal
-                  # with the file either (e.g. because of permissions)
-                  it { should be :removed }
-
-                  it 'should not unset record' do
-                    expect(async_record).to_not receive(:unset_path)
-                  end
-                end
-
-                context 'with available md5' do
-                  let(:md5) { 'd41d8cd98f00b204e9800998ecf8427e' }
-
-                  context 'with same md5 in record' do
-                    let(:record_md5) { md5 }
-                    it { should be_nil }
-                  end
-
-                  context 'with no md5 in record' do
-                    let(:record_md5) { nil }
-                    it { should be_nil }
-                  end
-
-                  context 'with different md5 in record' do
-                    let(:record_md5) { 'foo' }
-                    it { should be :modified }
-
-                    it 'sets path in record with expected data' do
-                      expect(async_record).to receive(:update_file).
-                        with(path, 'file.rb', expected_data. merge(md5: md5))
-                      subject
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    context 'with empty record' do
-      let(:record_data) { {} }
-
-      context 'with existing path' do
-        let(:stat) do
-          instance_double(
-            File::Stat,
-            mtime: 1234,
-            mode: 0645
-          )
-        end
-
-        before do
-          allow(::File).to receive(:lstat) { stat }
-        end
-
-        it 'returns added' do
-          expect(subject).to eq :added
-        end
-
-        it 'sets path in record with expected data' do
-          expect(async_record).to receive(:update_file).
-            with(path, 'file.rb', expected_data)
-          subject
-        end
-      end
-    end
-  end
-
-  describe '#inaccurate_mac_time?' do
-    let(:stat) do
-      instance_double(File::Stat, mtime: mtime, atime: atime, ctime: ctime)
-    end
-
-    subject { Listen::File.inaccurate_mac_time?(stat) }
-
-    context 'with no accurate times' do
-      let(:mtime) { Time.at(1_234_567.0) }
-      let(:atime) { Time.at(1_234_567.0) }
-      let(:ctime) { Time.at(1_234_567.0) }
-      it { should be_truthy }
-    end
-
-    context 'with all accurate times' do
-      let(:mtime) { Time.at(1_234_567.89) }
-      let(:atime) { Time.at(1_234_567.89) }
-      let(:ctime) { Time.at(1_234_567.89) }
-      it { should be_falsey }
-    end
-
-    context 'with one accurate time' do
-      let(:mtime) { Time.at(1_234_567.0) }
-      let(:atime) { Time.at(1_234_567.89) }
-      let(:ctime) { Time.at(1_234_567.0) }
-      it { should be_falsey }
-    end
-  end
-end

data/spec/lib/listen/listener_spec.rb

@@ -1,482 +0,0 @@
-require 'spec_helper'
-
-include Listen
-
-describe Listener do
-  subject { described_class.new(options) }
-  let(:options) { {} }
-  let(:registry) { instance_double(Celluloid::Registry) }
-
-  let(:supervisor) do
-    instance_double(Celluloid::SupervisionGroup, add: true, pool: true)
-  end
-
-  let(:record) { instance_double(Record, terminate: true, build: true) }
-  let(:silencer) { instance_double(Silencer, configure: nil) }
-  let(:adapter) { instance_double(Adapter::Base, start: nil) }
-
-  before do
-    allow(Listen::Silencer).to receive(:new) { silencer }
-
-    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 }
-  end
-
-  describe 'initialize' do
-    it { should_not be_paused }
-
-    context 'with a block' do
-      describe 'block' do
-        subject { described_class.new('lib', &(proc {})) }
-        specify { expect(subject.block).to_not be_nil }
-      end
-    end
-
-    context 'with directories' do
-      describe 'directories' do
-        subject { described_class.new('lib', 'spec') }
-        expected = %w(lib spec).map { |dir| Pathname.pwd + dir }
-        specify { expect(subject.directories).to eq expected }
-      end
-    end
-  end
-
-  describe 'options' do
-    context 'default options' do
-      it 'sets default options' do
-        expect(subject.options).
-          to eq(
-            debug: false,
-            latency: nil,
-            wait_for_delay: 0.1,
-            force_polling: false,
-            polling_fallback_message: nil)
-      end
-    end
-
-    context 'custom options' do
-      subject do
-        described_class.new('lib', latency: 1.234, wait_for_delay: 0.85)
-      end
-
-      it 'sets new options on initialize' do
-        expect(subject.options).
-          to eq(
-            debug: false,
-            latency: 1.234,
-            wait_for_delay: 0.85,
-            force_polling: false,
-            polling_fallback_message: nil)
-      end
-    end
-  end
-
-  describe '#start' do
-    before do
-      allow(subject).to receive(:_start_adapter)
-      allow(silencer).to receive(:silenced?) { false }
-    end
-
-    it 'supervises change_pool' do
-      expect(supervisor).to receive(:pool).
-        with(Change, as: :change_pool, args: subject)
-
-      subject.start
-    end
-
-    it 'supervises adapter' do
-      allow(Adapter).to receive(:select) { Adapter::Polling }
-      options = [mq: subject, directories: []]
-      expect(supervisor).to receive(:add).
-        with(Adapter::Polling, as: :adapter, args: options)
-
-      subject.start
-    end
-
-    it 'supervises record' do
-      expect(supervisor).to receive(:add).
-        with(Record, as: :record, args: subject)
-
-      subject.start
-    end
-
-    it 'builds record' do
-      expect(record).to receive(:build)
-      subject.start
-    end
-
-    it 'sets paused to false' do
-      subject.start
-      expect(subject).to_not be_paused
-    end
-
-    it 'starts adapter' do
-      expect(subject).to receive(:_start_adapter)
-      subject.start
-    end
-
-    it 'calls block on changes' do
-      foo = instance_double(Pathname, to_s: 'foo', exist?: true)
-
-      dir = instance_double(Pathname)
-      allow(dir).to receive(:+).with('foo') { foo }
-
-      block_stub = instance_double(Proc)
-      subject.block = block_stub
-      expect(block_stub).to receive(:call).with(['foo'], [], [])
-      subject.start
-      subject.queue(:file, :modified, dir, 'foo')
-      sleep 0.25
-    end
-  end
-
-  describe '#stop' do
-    before do
-      allow(Celluloid::SupervisionGroup).to receive(:run!) { supervisor }
-      subject.start
-    end
-
-    it 'terminates supervisor' do
-      expect(supervisor).to receive(:terminate)
-      subject.stop
-    end
-  end
-
-  describe '#pause' do
-    before { subject.start }
-    it 'sets paused to true' do
-      subject.pause
-      expect(subject).to be_paused
-    end
-  end
-
-  describe '#unpause' do
-    before do
-      subject.start
-      subject.pause
-    end
-
-    it 'sets paused to false' do
-      subject.unpause
-      expect(subject).to_not be_paused
-    end
-  end
-
-  describe '#paused?' do
-    before { subject.start }
-    it 'returns true when paused' do
-      subject.paused = true
-      expect(subject).to be_paused
-    end
-    it 'returns false when not paused (nil)' do
-      subject.paused = nil
-      expect(subject).not_to be_paused
-    end
-    it 'returns false when not paused (false)' do
-      subject.paused = false
-      expect(subject).not_to be_paused
-    end
-  end
-
-  describe '#listen?' do
-    context 'when processing' do
-      before { subject.start }
-      it { should be_processing }
-    end
-
-    context 'when stopped' do
-      it { should_not be_processing }
-    end
-
-    context 'when paused' do
-      before do
-        subject.start
-        subject.pause
-      end
-      it { should_not be_processing }
-    end
-  end
-
-  describe '#ignore' do
-    context 'with existing ignore options' do
-      let(:options) { { ignore: /bar/ } }
-
-      it 'adds up to existing ignore options' do
-        expect(silencer).to receive(:configure).with(options)
-        subject.ignore(/foo/)
-        expect(subject.options).to include(ignore: [/bar/, /foo/])
-      end
-    end
-
-    context 'with existing ignore options (array)' do
-      let(:options) { { ignore: [/bar/] } }
-
-      it 'adds up to existing ignore options' do
-        expect(silencer).to receive(:configure).with(options)
-        subject.ignore(/foo/)
-        expect(subject.options).to include(ignore: [[/bar/], /foo/])
-      end
-    end
-  end
-
-  describe '#ignore!' do
-    context 'with no existing options' do
-      let(:options) { {} }
-
-      it 'sets options' do
-        expect(silencer).to receive(:configure).with(options)
-        subject
-      end
-    end
-
-    context 'with existing ignore! options' do
-      let(:options) { { ignore!: /bar/ } }
-
-      it 'overwrites existing ignore options' do
-        expect(silencer).to receive(:configure).with(options)
-        subject.ignore!([/foo/])
-        expect(subject.options).to include(ignore!: [/foo/])
-      end
-    end
-
-    context 'with existing ignore options' do
-      let(:options) { { ignore: /bar/ } }
-
-      it 'deletes ignore options' do
-        expect(silencer).to receive(:configure).with(options)
-        subject.ignore!([/foo/])
-        expect(subject.options).to_not include(ignore: /bar/)
-      end
-    end
-  end
-
-  describe '#only' do
-    context 'with existing only options' do
-      let(:options) { { only: /bar/ } }
-
-      it 'overwrites existing ignore options' do
-        expect(silencer).to receive(:configure).with(options)
-        subject.only([/foo/])
-        expect(subject.options).to include(only: [/foo/])
-      end
-    end
-  end
-
-  describe '_wait_for_changes' do
-    it 'gets two changes and calls the block once' do
-      allow(silencer).to receive(:silenced?) { false }
-
-      subject.block = proc do |modified, added, _|
-        expect(modified).to eql(['foo/bar.txt'])
-        expect(added).to eql(['foo/baz.txt'])
-      end
-
-      bar = instance_double(
-        Pathname,
-        to_s: 'foo/bar.txt',
-        exist?: true,
-        directory?: false)
-
-      baz = instance_double(
-        Pathname,
-        to_s: 'foo/baz.txt',
-        exist?: true,
-        directory?: false)
-
-      dir = instance_double(Pathname)
-      expect(dir).to receive(:+).with('bar.txt') { bar }
-      expect(dir).to receive(:+).with('baz.txt') { baz }
-
-      subject.start
-      subject.queue(:file, :modified, dir, 'bar.txt', {})
-      subject.queue(:file, :added, dir, 'baz.txt', {})
-      sleep 0.25
-    end
-  end
-
-  describe '_smoosh_changes' do
-    it 'recognizes rename from temp file' do
-      bar = instance_double(
-        Pathname,
-        to_s: 'bar',
-        exist?: true,
-        directory?: false)
-
-      foo = instance_double(Pathname, to_s: 'foo')
-      allow(foo).to receive(:+).with('bar') { bar }
-
-      changes = [
-        [:file, :modified, foo, 'bar'],
-        [:file, :removed, foo, 'bar'],
-        [:file, :added, foo, 'bar'],
-        [:file, :modified, foo, 'bar']
-      ]
-      allow(silencer).to receive(:silenced?) { false }
-      smooshed = subject.send :_smoosh_changes, changes
-      expect(smooshed).to eq(modified: ['bar'], added: [], removed: [])
-    end
-
-    it 'ignores deleted temp file' do
-      bar = instance_double(
-        Pathname,
-        to_s: 'bar',
-        exist?: false)
-
-      foo = instance_double(Pathname, to_s: 'foo')
-      allow(foo).to receive(:+).with('bar') { bar }
-
-      changes = [
-        [:file, :added, foo, 'bar'],
-        [:file, :modified, foo, 'bar'],
-        [:file, :removed, foo, 'bar'],
-        [:file, :modified, foo, 'bar']
-      ]
-      allow(silencer).to receive(:silenced?) { false }
-      smooshed = subject.send :_smoosh_changes, changes
-      expect(smooshed).to eq(modified: [], added: [], removed: [])
-    end
-
-    it 'recognizes double move as modification' do
-      # e.g. "mv foo x && mv x foo" is like "touch foo"
-      bar = instance_double(
-        Pathname,
-        to_s: 'bar',
-        exist?: true)
-
-      dir = instance_double(Pathname, to_s: 'foo')
-      allow(dir).to receive(:+).with('bar') { bar }
-
-      changes = [
-        [:file, :removed, dir, 'bar'],
-        [:file, :added, dir, 'bar']
-      ]
-      allow(silencer).to receive(:silenced?) { false }
-      smooshed = subject.send :_smoosh_changes, changes
-      expect(smooshed).to eq(modified: ['bar'], added: [], removed: [])
-    end
-
-    context 'with cookie' do
-
-      it 'recognizes single moved_to as add' do
-        foo = instance_double(
-          Pathname,
-          to_s: 'foo',
-          exist?: true)
-
-        dir = instance_double(Pathname, to_s: 'foo')
-        allow(dir).to receive(:+).with('foo') { foo }
-
-        changes = [[:file, :moved_to, dir, 'foo', cookie: 4321]]
-        expect(silencer).to receive(:silenced?).
-          with(Pathname('foo'), :file) { false }
-
-        smooshed = subject.send :_smoosh_changes, changes
-        expect(smooshed).to eq(modified: [], added: ['foo'], removed: [])
-      end
-
-      it 'recognizes related moved_to as add' do
-        foo = instance_double(
-          Pathname,
-          to_s: 'foo',
-          exist?: true,
-          directory?: false)
-
-        bar = instance_double(
-          Pathname,
-          to_s: 'bar',
-          exist?: true,
-          directory?: false)
-
-        dir = instance_double(Pathname)
-        allow(dir).to receive(:+).with('foo') { foo }
-        allow(dir).to receive(:+).with('bar') { bar }
-
-        changes = [
-          [:file, :moved_from, dir, 'foo', cookie: 4321],
-          [:file, :moved_to, dir, 'bar', cookie: 4321]
-        ]
-
-        expect(silencer).to receive(:silenced?).
-          twice.with(Pathname('foo'), :file) { false }
-
-        expect(silencer).to receive(:silenced?).
-          with(Pathname('bar'), :file) { false }
-
-        smooshed = subject.send :_smoosh_changes, changes
-        expect(smooshed).to eq(modified: [], added: ['bar'], removed: [])
-      end
-
-      # Scenario with workaround for editors using rename()
-      it 'recognizes related moved_to with ignored moved_from as modify' do
-
-        ignored = instance_double(
-          Pathname,
-          to_s: 'ignored',
-          exist?: true,
-          directory?: false)
-
-        foo = instance_double(
-          Pathname,
-          to_s: 'foo',
-          exist?: true,
-          directory?: false)
-
-        dir = instance_double(Pathname)
-        allow(dir).to receive(:+).with('foo') { foo }
-        allow(dir).to receive(:+).with('ignored') { ignored }
-
-        changes = [
-          [:file, :moved_from, dir, 'ignored', cookie: 4321],
-          [:file, :moved_to, dir, 'foo', cookie: 4321]
-        ]
-
-        expect(silencer).to receive(:silenced?).
-          with(Pathname('ignored'), :file) { true }
-
-        expect(silencer).to receive(:silenced?).
-          with(Pathname('foo'), :file) { false }
-
-        smooshed = subject.send :_smoosh_changes, changes
-        expect(smooshed).to eq(modified: ['foo'], added: [], removed: [])
-      end
-    end
-
-    context 'with no cookie' do
-      context 'with ignored file' do
-        let(:dir) { instance_double(Pathname) }
-        let(:ignored) { instance_double(Pathname, to_s: 'foo', exist?: true) }
-
-        before do
-          expect(silencer).to receive(:silenced?).
-            with(Pathname('ignored'), :file) { true }
-
-          allow(dir).to receive(:+).with('ignored') { ignored }
-        end
-
-        it 'recognizes properly ignores files' do
-          changes = [[:file, :modified, dir, 'ignored']]
-          smooshed = subject.send :_smoosh_changes, changes
-          expect(smooshed).to eq(modified: [], added: [], removed: [])
-        end
-      end
-    end
-  end
-
-  context 'when listener is stopped' do
-
-    before do
-      allow(registry).to receive(:[]).with(:change_pool) { nil }
-      subject.stop
-    end
-
-    let(:dir) { instance_double(Pathname) }
-
-    it 'queuing does not crash when no worker is available' do
-      expect do
-        subject.send(:_queue_raw_change, :dir, dir, 'path', recursive: true)
-      end.to_not raise_error
-    end
-  end
-end