listen 2.7.5 → 2.7.6

data/spec/lib/listen/file_spec.rb

@@ -1,143 +1,256 @@
 require 'spec_helper'
 
 describe Listen::File do
-  let(:registry) { double(Celluloid::Registry) }
-  let(:listener) { double(Listen::Listener, registry: registry, options: {}) }
+  let(:async_record) do
+    instance_double(
+      Listen::Record,
+      set_path: true,
+      unset_path: true,
+    )
+  end
 
   let(:record) do
-    double(Listen::Record, async: double(set_path: true, unset_path: true))
+    instance_double(
+      Listen::Record,
+      async: async_record,
+      file_data: record_data
+    )
   end
 
-  let(:path) { Pathname.new(Dir.pwd) }
+  let(:path) { Pathname.pwd }
+  let(:file_path) { path + 'file.rb' }
+  let(:subject) { described_class.change(record, file_path) }
+
   around { |example| fixtures { example.run } }
-  before { registry.stub(:[]).with(:record) { record } }
 
-  describe '#change' do
-    let(:file_path) { path.join('file.rb') }
-    let(:file) { Listen::File.new(listener, file_path) }
+  before { allow(::File).to receive(:lstat) { fail 'Not stubbed!' } }
 
+  describe '#change' do
     let(:expected_data) do
-      { type: 'File', mtime: kind_of(Float), mode: kind_of(Integer) }
+      { mtime: kind_of(Float), mode: kind_of(Integer) }
     end
 
-    context 'path present in record' do
+    context 'with file in record' do
       let(:record_mtime) { nil }
       let(:record_md5) { nil }
       let(:record_mode) { nil }
 
       let(:record_data) do
-        { type: 'File',
+        { type: :file,
           mtime: record_mtime,
           md5: record_md5,
           mode: record_mode }
       end
 
-      before do
-        record.stub_chain(:future, :file_data) { double(value: record_data) }
-      end
+      context 'with non-existing file' do
+        before { allow(::File).to receive(:lstat) { fail Errno::ENOENT } }
+
+        it { should be :removed }
 
-      context 'non-existing path' do
-        it 'returns added' do
-          expect(file.change).to eq :removed
-        end
         it 'sets path in record' do
-          expect(record.async).to receive(:unset_path).with(file_path)
-          file.change
+          expect(async_record).to receive(:unset_path).with(file_path)
+          subject
         end
       end
 
-      context 'existing path' do
-        around do |example|
-          touch file_path
-          example.run
+      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
 
-        context 'old record path mtime' do
-          let(:record_mtime) { (Time.now - 1).to_f }
+        before do
+          allow(::File).to receive(:lstat) { stat }
+          allow(Digest::MD5).to receive(:file) { double(:md5, digest: md5) }
+        end
 
-          it 'returns modified' do
-            expect(file.change).to eq :modified
-          end
+        context 'with different mode in record' do
+          let(:record_mode) { 0722 }
 
-          it 'sets path in record with expected data' do
-            expect(record.async).to receive(:set_path).
-              with(file_path, expected_data)
+          it { should be :modified }
 
-            file.change
+          it 'sets path in record with expected data' do
+            expect(async_record).to receive(:set_path).
+              with(:file, file_path, expected_data)
+            subject
           end
         end
 
-        context 'same record path mtime' do
-          let(:record_mtime) { ::File.lstat(file_path).mtime.to_f }
-          let(:record_mode)  { ::File.lstat(file_path).mode }
+        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 }
 
-          context 'same record path mode' do
-            it 'returns nil' do
-              expect(file.change).to be_nil
+            it { should be :modified }
+
+            it 'sets path in record with expected data' do
+              expect(async_record).to receive(:set_path).
+                with(:file, file_path, expected_data)
+              subject
             end
           end
 
-          context 'diferent record path mode' do
-            let(:record_mode) { 'foo' }
+          context 'with later mtime than in record' do
+            let(:record_mtime) { stat_mtime.to_f + 123.45 }
+
+            it { should be :modified }
 
-            it 'returns modified' do
-              expect(file.change).to eq :modified
+            it 'sets path in record with expected data' do
+              expect(async_record).to receive(:set_path).
+                with(:file, file_path, expected_data)
+              subject
             end
           end
 
-          context 'same record path md5' do
-            it 'returns nil' do
-              expect(file.change).to be_nil
+          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(1401235714.123) }
+              let(:stat_atime) { Time.at(1401235714.123) }
+              let(:stat_ctime) { Time.at(1401235714.123) }
+              let(:record_mtime) { stat_mtime.to_f }
+              it { should be_nil }
             end
-          end
 
-          if darwin?
-            context 'different record path md5' do
-              let(:record_md5) { 'foo' }
-              let(:expected_data) do
-                { type: 'File',
-                  mtime: kind_of(Float),
-                  mode: kind_of(Integer),
-                  md5: kind_of(String) }
-              end
+            context 'with inaccurate stat times' do
+              let(:stat_mtime) { Time.at(1401235714.0) }
+              let(:stat_atime) { Time.at(1401235714.0) }
+              let(:stat_ctime) { Time.at(1401235714.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 } }
 
-              it 'returns modified' do
-                expect(file.change).to eq :modified
+                # NOTE: if real mtime is ???14.99, the
+                # saved mtime is ???14.0
+                let(:now) { Time.at(1401235716.00) }
+                it { should be_nil }
               end
-              it 'sets path in record with expected data' do
-                expect(record.async).to receive(:set_path).
-                  with(file_path, expected_data)
 
-                file.change
+              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(1401235715.999999) }
+
+                before { allow(Time).to receive(:now) { now } }
+
+                context 'without available md5' do
+                  let(:md5) { fail Errno::ENOENT }
+
+                  # Treat is as an ignored 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 nil }
+
+                  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(:set_path).
+                        with(:file, file_path, expected_data. merge(md5: md5))
+                      subject
+                    end
+                  end
+                end
               end
             end
           end
-
         end
       end
     end
 
-    context 'path not present in record' do
-      before { record.stub_chain(:future, :file_data) { double(value: {}) } }
+    context 'with empty record' do
+      let(:record_data) { {} }
 
-      context 'existing path' do
-        around do |example|
-          touch file_path
-          example.run
+      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(file.change).to eq :added
+          expect(subject).to eq :added
         end
 
         it 'sets path in record with expected data' do
-          expect(record.async).to receive(:set_path).
-            with(file_path, expected_data)
+          expect(async_record).to receive(:set_path).
+            with(:file, file_path, expected_data)
 
-          file.change
+          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(1234567.0) }
+      let(:atime) { Time.at(1234567.0) }
+      let(:ctime) { Time.at(1234567.0) }
+      it { should be_truthy }
+    end
+
+    context 'with all accurate times' do
+      let(:mtime) { Time.at(1234567.89) }
+      let(:atime) { Time.at(1234567.89) }
+      let(:ctime) { Time.at(1234567.89) }
+      it { should be_falsey }
+    end
+
+    context 'with one accurate time' do
+      let(:mtime) { Time.at(1234567.0) }
+      let(:atime) { Time.at(1234567.89) }
+      let(:ctime) { Time.at(1234567.0) }
+      it { should be_falsey }
+    end
+  end
 end

data/spec/lib/listen/listener_spec.rb

@@ -1,227 +1,220 @@
 require 'spec_helper'
 
 describe Listen::Listener do
-  let(:listener) { Listen::Listener.new(options) }
+  subject { described_class.new(options) }
   let(:options) { {} }
-  let(:registry) { double(Celluloid::Registry, :[]= => true) }
+  let(:registry) { instance_double(Celluloid::Registry, :[]= => true) }
 
   let(:supervisor) do
-    double(Celluloid::SupervisionGroup,
-           add: true,
-           pool: true)
+    instance_double(Celluloid::SupervisionGroup, add: true, pool: true)
   end
 
-  let(:record) { double(Listen::Record, terminate: true, build: true) }
-  let(:silencer) { double(Listen::Silencer, terminate: true) }
-  let(:adapter_class) { double(:adapter_class, local_fs?: true) }
-  let(:adapter) { double(Listen::Adapter::Base, class: adapter_class) }
-  let(:change_pool) { double(Listen::Change, terminate: true) }
-  let(:change_pool_async) { double('ChangePoolAsync') }
+  let(:record) { instance_double(Listen::Record, terminate: true, build: true) }
+  let(:silencer) { instance_double(Listen::Silencer, terminate: true) }
+  let(:adapter) { instance_double(Listen::Adapter::Base, start: nil) }
   before do
-    Celluloid::Registry.stub(:new) { registry }
-    Celluloid::SupervisionGroup.stub(:run!) { supervisor }
-    registry.stub(:[]).with(:silencer) { silencer }
-    registry.stub(:[]).with(:adapter) { adapter }
-    registry.stub(:[]).with(:record) { record }
-    registry.stub(:[]).with(:change_pool) { change_pool }
-
+    allow(Celluloid::Registry).to receive(:new) { registry }
+    allow(Celluloid::SupervisionGroup).to receive(:run!) { supervisor }
+    allow(registry).to receive(:[]).with(:silencer) { silencer }
+    allow(registry).to receive(:[]).with(:adapter) { adapter }
+    allow(registry).to receive(:[]).with(:record) { record }
   end
 
   describe 'initialize' do
-    it 'sets paused to false' do
-      expect(listener).not_to be_paused
-    end
+    it { should_not be_paused }
 
-    it 'sets block' do
-      block = proc {}
-      listener = Listen::Listener.new('lib', &block)
-      expect(listener.block).not_to be_nil
+    context 'with a block' do
+      describe 'block' do
+        subject { described_class.new('lib', &(proc {})) }
+        specify { expect(subject.block).to_not be_nil }
+      end
     end
 
-    it 'sets directories with realpath' do
-      listener = Listen::Listener.new('lib', 'spec')
-      expected = %w(lib spec).map { |dir| Pathname.pwd.join(dir) }
-      expect(listener.directories).to eq expected
+    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
-    it 'sets default options' do
-      expect(listener.options).to eq(
-                                       debug: false,
-                                       latency: nil,
-                                       wait_for_delay: 0.1,
-                                       force_polling: false,
-                                       polling_fallback_message: nil)
-    end
-
-    it 'sets new options on initialize' do
-      listener = Listen::Listener.new('lib',
-                                      latency: 1.234,
-                                      wait_for_delay: 0.85)
-
-      expect(listener.options).to eq(
-                                       debug: false,
-                                       latency: 1.234,
-                                       wait_for_delay: 0.85,
-                                       force_polling: false,
-                                       polling_fallback_message: nil)
+    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
-      adapter.stub_chain(:async, :start)
-      silencer.stub(:silenced?) { false }
+      allow(subject).to receive(:_start_adapter)
+      allow(silencer).to receive(:silenced?) { false }
     end
 
     it 'registers silencer' do
       expect(supervisor).to receive(:add).
-        with(Listen::Silencer, as: :silencer, args: listener)
+        with(Listen::Silencer, as: :silencer, args: subject)
 
-      listener.start
+      subject.start
     end
 
     it 'supervises change_pool' do
       expect(supervisor).to receive(:pool).
-        with(Listen::Change, as: :change_pool, args: listener)
+        with(Listen::Change, as: :change_pool, args: subject)
 
-      listener.start
+      subject.start
     end
 
     it 'supervises adaper' do
-      Listen::Adapter.stub(:select) { Listen::Adapter::Polling }
+      allow(Listen::Adapter).to receive(:select) { Listen::Adapter::Polling }
       expect(supervisor).to receive(:add).
-        with(Listen::Adapter::Polling, as: :adapter, args: listener)
+        with(Listen::Adapter::Polling, as: :adapter, args: subject)
 
-      listener.start
+      subject.start
     end
 
     it 'supervises record' do
       expect(supervisor).to receive(:add).
-        with(Listen::Record, as: :record, args: listener)
+        with(Listen::Record, as: :record, args: subject)
 
-      listener.start
+      subject.start
     end
 
     it 'builds record' do
       expect(record).to receive(:build)
-      listener.start
+      subject.start
     end
 
     it 'sets paused to false' do
-      listener.start
-      expect(listener.paused).to be_false
+      subject.start
+      expect(subject).to_not be_paused
     end
 
-    it 'starts adapter asynchronously' do
-      async_stub = double
-      expect(adapter).to receive(:async) { async_stub }
-      expect(async_stub).to receive(:start)
-      listener.start
-    end
-
-    it 'starts adapter asynchronously' do
-      async_stub = double
-      expect(adapter).to receive(:async) { async_stub }
-      expect(async_stub).to receive(:start)
-      listener.start
+    it 'starts adapter' do
+      expect(subject).to receive(:_start_adapter)
+      subject.start
     end
 
     it 'calls block on changes' do
-      foo = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
-      listener.changes = [{ modified: foo }]
-      block_stub = double('block')
-      listener.block = block_stub
+      foo = instance_double(Pathname, to_s: 'foo', exist?: true)
+
+      block_stub = instance_double(Proc)
+      subject.block = block_stub
       expect(block_stub).to receive(:call).with(['foo'], [], [])
-      listener.start
+      subject.start
+      subject.queue(:file, :modified, 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
-      listener.supervisor = supervisor
       expect(supervisor).to receive(:terminate)
-      listener.stop
+      subject.stop
     end
   end
 
   describe '#pause' do
+    before { subject.start }
     it 'sets paused to true' do
-      listener.pause
-      expect(listener.paused).to be_true
+      subject.pause
+      expect(subject).to be_paused
     end
   end
 
   describe '#unpause' do
-    it 'builds record' do
-      expect(record).to receive(:build)
-      listener.unpause
+    before do
+      subject.start
+      subject.pause
     end
 
     it 'sets paused to false' do
-      record.stub(:build)
-      listener.unpause
-      expect(listener.paused).to be_false
+      subject.unpause
+      expect(subject).to_not be_paused
     end
   end
 
   describe '#paused?' do
+    before { subject.start }
     it 'returns true when paused' do
-      listener.paused = true
-      expect(listener).to be_paused
+      subject.paused = true
+      expect(subject).to be_paused
     end
     it 'returns false when not paused (nil)' do
-      listener.paused = nil
-      expect(listener).not_to be_paused
+      subject.paused = nil
+      expect(subject).not_to be_paused
     end
     it 'returns false when not paused (false)' do
-      listener.paused = false
-      expect(listener).not_to be_paused
+      subject.paused = false
+      expect(subject).not_to be_paused
     end
   end
 
   describe '#listen?' do
-    it 'returns true when not paused (false)' do
-      listener.paused = false
-      listener.stopping = false
-      expect(listener.listen?).to be_true
+    context 'when processing' do
+      before { subject.start }
+      it { should be_processing }
     end
-    it 'returns false when not paused (nil)' do
-      listener.paused = nil
-      listener.stopping = false
-      expect(listener.listen?).to be_false
-    end
-    it 'returns false when paused' do
-      listener.paused = true
-      listener.stopping = false
-      expect(listener.listen?).to be_false
+
+    context 'when stopped' do
+      it { should_not be_processing }
     end
-    it 'returns false when stopped' do
-      listener.paused = false
-      listener.stopping = true
-      expect(listener.listen?).to be_false
+
+    context 'when paused' do
+      before do
+        subject.start
+        subject.pause
+      end
+      it { should_not be_processing }
     end
   end
 
   describe '#ignore' do
-    let(:new_silencer) { double(Listen::Silencer) }
-    before { Celluloid::Actor.stub(:[]=) }
+    let(:new_silencer) { instance_double(Listen::Silencer) }
+    before { allow(Celluloid::Actor).to receive(:[]=) }
 
     it 'resets silencer actor' do
-      expect(Listen::Silencer).to receive(:new).with(listener) { new_silencer }
+      expect(Listen::Silencer).to receive(:new).with(subject) { new_silencer }
       expect(registry).to receive(:[]=).with(:silencer, new_silencer)
-      listener.ignore(/foo/)
+      subject.ignore(/foo/)
     end
 
     context 'with existing ignore options' do
       let(:options) { { ignore: /bar/ } }
 
       it 'adds up to existing ignore options' do
-        expect(Listen::Silencer).to receive(:new).with(listener)
-        listener.ignore(/foo/)
-        expect(listener.options).to include(ignore: [/bar/, /foo/])
+        expect(Listen::Silencer).to receive(:new).with(subject)
+        subject.ignore(/foo/)
+        expect(subject.options).to include(ignore: [/bar/, /foo/])
       end
     end
 
@@ -229,31 +222,31 @@ describe Listen::Listener do
       let(:options) { { ignore: [/bar/] } }
 
       it 'adds up to existing ignore options' do
-        expect(Listen::Silencer).to receive(:new).with(listener)
-        listener.ignore(/foo/)
-        expect(listener.options).to include(ignore: [[/bar/], /foo/])
+        expect(Listen::Silencer).to receive(:new).with(subject)
+        subject.ignore(/foo/)
+        expect(subject.options).to include(ignore: [[/bar/], /foo/])
       end
     end
   end
 
   describe '#ignore!' do
-    let(:new_silencer) { double(Listen::Silencer) }
-    before { Celluloid::Actor.stub(:[]=) }
+    let(:new_silencer) { instance_double(Listen::Silencer) }
+    before { allow(Celluloid::Actor).to receive(:[]=) }
 
     it 'resets silencer actor' do
-      expect(Listen::Silencer).to receive(:new).with(listener) { new_silencer }
+      expect(Listen::Silencer).to receive(:new).with(subject) { new_silencer }
       expect(registry).to receive(:[]=).with(:silencer, new_silencer)
-      listener.ignore!(/foo/)
-      expect(listener.options).to include(ignore!: /foo/)
+      subject.ignore!(/foo/)
+      expect(subject.options).to include(ignore!: /foo/)
     end
 
     context 'with existing ignore! options' do
       let(:options) { { ignore!: /bar/ } }
 
       it 'overwrites existing ignore options' do
-        expect(Listen::Silencer).to receive(:new).with(listener)
-        listener.ignore!([/foo/])
-        expect(listener.options).to include(ignore!: [/foo/])
+        expect(Listen::Silencer).to receive(:new).with(subject)
+        subject.ignore!([/foo/])
+        expect(subject.options).to include(ignore!: [/foo/])
       end
     end
 
@@ -261,166 +254,190 @@ describe Listen::Listener do
       let(:options) { { ignore: /bar/ } }
 
       it 'deletes ignore options' do
-        expect(Listen::Silencer).to receive(:new).with(listener)
-        listener.ignore!([/foo/])
-        expect(listener.options).to_not include(ignore: /bar/)
+        expect(Listen::Silencer).to receive(:new).with(subject)
+        subject.ignore!([/foo/])
+        expect(subject.options).to_not include(ignore: /bar/)
       end
     end
   end
 
   describe '#only' do
-    let(:new_silencer) { double(Listen::Silencer) }
-    before { Celluloid::Actor.stub(:[]=) }
+    let(:new_silencer) { instance_double(Listen::Silencer) }
+    before { allow(Celluloid::Actor).to receive(:[]=) }
 
     it 'resets silencer actor' do
-      expect(Listen::Silencer).to receive(:new).with(listener) { new_silencer }
+      expect(Listen::Silencer).to receive(:new).with(subject) { new_silencer }
       expect(registry).to receive(:[]=).with(:silencer, new_silencer)
-      listener.only(/foo/)
+      subject.only(/foo/)
     end
 
     context 'with existing only options' do
       let(:options) { { only: /bar/ } }
 
       it 'overwrites existing ignore options' do
-        expect(Listen::Silencer).to receive(:new).with(listener)
-        listener.only([/foo/])
-        expect(listener.options).to include(only: [/foo/])
+        expect(Listen::Silencer).to receive(:new).with(subject)
+        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
-      silencer.stub(:silenced?) { false }
-
-      fake_time = 0
-      listener.stub(:sleep) do |sec|
-        fake_time += sec
-        listener.stopping = true if fake_time > 1
-      end
+      allow(silencer).to receive(:silenced?) { false }
 
-      listener.block = proc do |modified, added, _|
+      subject.block = proc do |modified, added, _|
         expect(modified).to eql(['foo.txt'])
         expect(added).to eql(['bar.txt'])
       end
 
-      foo = double(Pathname, to_s: 'foo.txt', exist?: true, directory?: false)
-      bar = double(Pathname, to_s: 'bar.txt', exist?: true, directory?: false)
-
-      i = 0
-      listener.stub(:_pop_changes) do
-        i += 1
-        case i
-        when 1
-          []
-        when 2
-          [{ modified: foo }]
-        when 3
-          [{ added: bar }]
-        else
-          []
-        end
-      end
-
-      listener.send :_wait_for_changes
+      foo = instance_double(
+        Pathname,
+        to_s: 'foo.txt',
+        exist?: true,
+        directory?: false)
+
+      bar = instance_double(
+        Pathname,
+        to_s: 'bar.txt',
+        exist?: true,
+        directory?: false)
+
+      subject.start
+      subject.queue(:file, :modified, foo, {})
+      subject.queue(:file, :added, bar, {})
+      sleep 0.25
     end
   end
 
   describe '_smoosh_changes' do
     it 'recognizes rename from temp file' do
-      path = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
+      path = instance_double(
+        Pathname,
+        to_s: 'foo',
+        exist?: true,
+        directory?: false)
+
       changes = [
-        { modified: path },
-        { removed: path },
-        { added: path },
-        { modified: path }
+        [:file, :modified, path],
+        [:file, :removed, path],
+        [:file, :added, path],
+        [:file, :modified, path]
       ]
-      silencer.stub(:silenced?) { false }
-      smooshed = listener.send :_smoosh_changes, changes
+      allow(silencer).to receive(:silenced?) { false }
+      smooshed = subject.send :_smoosh_changes, changes
       expect(smooshed).to eq(modified: ['foo'], added: [], removed: [])
     end
 
     it 'recognizes deleted temp file' do
-      path = double(Pathname, to_s: 'foo', exist?: false, directory?: false)
+      path = instance_double(
+        Pathname,
+        to_s: 'foo',
+        exist?: false,
+        directory?: false)
+
       changes = [
-        { added: path },
-        { modified: path },
-        { removed: path },
-        { modified: path }
+        [:file, :added, path],
+        [:file, :modified, path],
+        [:file, :removed, path],
+        [:file, :modified, path]
       ]
-      silencer.stub(:silenced?) { false }
-      smooshed = listener.send :_smoosh_changes, changes
+      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"
-      path = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
+      path = instance_double(
+        Pathname,
+        to_s: 'foo',
+        exist?: true,
+        directory?: false)
+
       changes = [
-        { removed: path },
-        { added: path }
+        [:file, :removed, path],
+        [:file, :added, path]
       ]
-      silencer.stub(:silenced?) { false }
-      smooshed = listener.send :_smoosh_changes, changes
+      allow(silencer).to receive(:silenced?) { false }
+      smooshed = subject.send :_smoosh_changes, changes
       expect(smooshed).to eq(modified: ['foo'], added: [], removed: [])
     end
 
     context 'with cookie' do
 
       it 'recognizes single moved_to as add' do
-        foo = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
-        changes = [{ moved_to: foo , cookie: 4321 }]
-        expect(silencer).to receive(:silenced?).with(foo, 'File') { false }
-        smooshed = listener.send :_smoosh_changes, changes
+        foo = instance_double(
+          Pathname,
+          to_s: 'foo',
+          exist?: true,
+          directory?: false)
+
+        changes = [[:file, :moved_to, foo, cookie: 4321]]
+        expect(silencer).to receive(:silenced?).with(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 = double(:foo, to_s: 'foo', exist?: true, directory?: false)
-        bar = double(:bar, to_s: 'bar', exist?: true, directory?: false)
+        foo = instance_double(
+          Pathname,
+          to_s: 'foo',
+          exist?: true,
+          directory?: false)
+
+        bar = instance_double(
+          Pathname,
+          to_s: 'bar',
+          exist?: true,
+          directory?: false)
+
         changes = [
-          { moved_from: foo , cookie: 4321 },
-          { moved_to: bar, cookie: 4321 }
+          [:file, :moved_from, foo , cookie: 4321],
+          [:file, :moved_to, bar, cookie: 4321]
         ]
 
         expect(silencer).to receive(:silenced?).
-          twice.with(foo, 'File') { false }
+          twice.with(foo, :file) { false }
 
-        expect(silencer).to receive(:silenced?).with(bar, 'File') { false }
-        smooshed = listener.send :_smoosh_changes, changes
+        expect(silencer).to receive(:silenced?).with(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 = double(Pathname,
-                         to_s: 'foo',
-                         exist?: true,
-                         directory?: false)
+        ignored = instance_double(
+          Pathname,
+          to_s: 'foo',
+          exist?: true,
+          directory?: false)
+
+        foo = instance_double(
+          Pathname,
+          to_s: 'foo',
+          exist?: true,
+          directory?: false)
 
-        foo = double(Pathname, to_s: 'foo', exist?: true, directory?: false)
         changes = [
-          { moved_from: ignored, cookie: 4321 },
-          { moved_to: foo , cookie: 4321 }
+          [:file, :moved_from, ignored, cookie: 4321],
+          [:file, :moved_to, foo , cookie: 4321]
         ]
-        expect(silencer).to receive(:silenced?).with(ignored, 'File') { true }
-        expect(silencer).to receive(:silenced?).with(foo, 'File') { false }
-        smooshed = listener.send :_smoosh_changes, changes
+        expect(silencer).to receive(:silenced?).with(ignored, :file) { true }
+        expect(silencer).to receive(:silenced?).with(foo, :file) { false }
+        smooshed = subject.send :_smoosh_changes, changes
         expect(smooshed).to eq(modified: ['foo'], added: [], removed: [])
       end
     end
 
     context 'with no cookie' do
       it 'recognizes properly ignores files' do
-        ignored = double(Pathname,
-                         to_s: 'foo',
-                         exist?: true,
-                         directory?: false)
-
-        changes = [{ modified: ignored }]
-        expect(silencer).to receive(:silenced?).with(ignored, 'File') { true }
-        smooshed = listener.send :_smoosh_changes, changes
+        ignored = instance_double(Pathname, to_s: 'foo', exist?: true)
+
+        changes = [[:file, :modified, ignored]]
+        expect(silencer).to receive(:silenced?).with(ignored, :file) { true }
+        smooshed = subject.send :_smoosh_changes, changes
         expect(smooshed).to eq(modified: [], added: [], removed: [])
       end
     end