listen 2.7.5 → 2.7.6

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

@@ -1,60 +1,45 @@
 require 'spec_helper'
 
 describe Listen::Adapter::Polling do
-  let(:registry) { double(Celluloid::Registry) }
-  let(:listener) do
-    double(Listen::Listener,
-           registry: registry,
-           options: {},
-           listen?: true)
+  describe 'class' do
+    subject { described_class }
+    it { should be_local_fs }
+    it { should be_usable }
   end
 
-  let(:adapter) { described_class.new(listener) }
-  let(:change_pool) { double(Listen::Change, terminate: true) }
-  let(:change_pool_async) { double('ChangePoolAsync') }
+  subject { described_class.new(listener) }
 
-  before do
-    change_pool.stub(:async) { change_pool_async }
-    registry.stub(:[]).with(:change_pool) { change_pool }
-  end
+  let(:options) { {} }
+  let(:listener) { instance_double(Listen::Listener, options: options) }
+  let(:worker) { instance_double(Listen::Change) }
 
-  describe '.usable?' do
-    it 'returns always true' do
-      expect(described_class).to be_usable
-    end
-  end
+  before { allow(listener).to receive(:async).with(:change_pool) { worker } }
 
   describe '#start' do
-    let(:directories) { ['directory_path'] }
-    before do
-      listener.stub(:options) { {} }
-      listener.stub(:directories) { directories }
-    end
+    before { allow(listener).to receive(:directories) { ['directory_path'] } }
 
     it 'notifies change on every listener directories path' do
-      expect(change_pool_async).to receive(:change).with(
+      expect(worker).to receive(:change).with(
+        :dir,
         'directory_path',
-        type: 'Dir',
         recursive: true)
 
-      t = Thread.new { adapter.start }
+      t = Thread.new { subject.start }
       sleep 0.25
       t.kill
     end
   end
 
   describe '#_latency' do
-    it 'returns default_latency with listener actor latency not present' do
-      expected_latency =  Listen::Adapter::Polling::DEFAULT_POLLING_LATENCY
-      expect(adapter.send(:_latency)).to eq expected_latency
+    subject { described_class.new(listener).send(:_latency) }
+
+    context 'with no overriding option' do
+      it { should eq described_class.const_get('DEFAULT_POLLING_LATENCY') }
     end
 
-    it 'returns latency from listener actor if present' do
-      listener.stub(:options) { { latency: 1234 } }
-      expect(adapter.send(:_latency)).to eq 1234
+    context 'with custom latency overriding' do
+      let(:options) { { latency: 1234 } }
+      it { should eq 1234 }
     end
   end
-
-  specify { expect(described_class).to be_local_fs }
-
 end

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

@@ -6,20 +6,23 @@ describe Listen::Adapter::TCP do
   let(:port) { 4000 }
 
   subject { described_class.new(listener) }
-  let(:registry) { double(Celluloid::Registry) }
+  let(:registry) { instance_double(Celluloid::Registry) }
 
   let(:listener) do
-    double(Listen::TCP::Listener,
-           registry: registry,
-           options: {},
-           host: host,
-           port: port)
+    instance_double(
+      Listen::Listener,
+      registry: registry,
+      options: {},
+      host: host,
+      port: port)
   end
 
-  let(:socket) { double(described_class::TCPSocket, close: true, recv: nil) }
+  let(:socket) do
+    instance_double(described_class::TCPSocket, close: true, recv: nil)
+  end
 
   before do
-    described_class::TCPSocket.stub(:new).and_return socket
+    allow(described_class::TCPSocket).to receive(:new).and_return socket
   end
 
   after do
@@ -69,16 +72,19 @@ describe Listen::Adapter::TCP do
   end
 
   describe '#run' do
-    let(:async) { double('TCP-adapter async', handle_data: true) }
-
     it 'handles data from socket' do
-      socket.stub(:recv).and_return 'foo', 'bar', nil
-      subject.stub(:async).and_return async
+      allow(socket).to receive(:recv).and_return 'foo', 'bar', nil
+
+      expect_any_instance_of(described_class).
+        to receive(:handle_data).with('foo')
 
-      expect(async).to receive(:handle_data).with 'foo'
-      expect(async).to receive(:handle_data).with 'bar'
+      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
 
@@ -93,7 +99,9 @@ describe Listen::Adapter::TCP do
     it 'handles messages accordingly' do
       message = Listen::TCP::Message.new
 
-      Listen::TCP::Message.stub(:from_buffer).and_return message, nil
+      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
 
@@ -104,20 +112,10 @@ describe Listen::Adapter::TCP do
 
   describe '#handle_message' do
     it 'notifies listener of path changes' do
-      message = Listen::TCP::Message.new(
-        'modified' => ['/foo', '/bar'],
-        'added'    => ['/baz'],
-        'removed'  => []
-      )
-
-      expect(subject.wrapped_object).
-        to receive(:_notify_change).with '/foo', change: :modified
-
-      expect(subject.wrapped_object).
-        to receive(:_notify_change).with '/bar', change: :modified
+      message = Listen::TCP::Message.new('file', 'modified', '/foo', {})
 
       expect(subject.wrapped_object).
-        to receive(:_notify_change).with '/baz', change: :added
+        to receive(:_notify_change).with :file, '/foo', change: :modified
 
       subject.handle_message message
     end

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

@@ -1,40 +1,14 @@
 require 'spec_helper'
 
 describe Listen::Adapter::Windows do
-  if windows?
-    let(:listener) { double(Listen::Listener) }
-    let(:adapter) { described_class.new(listener) }
+  describe 'class' do
+    subject { described_class }
+    it { should be_local_fs }
 
-    describe '.usable?' do
-      it 'returns always true' do
-        expect(described_class).to be_usable
-      end
-
-      it 'requires wdm gem' do
-        described_class.usable?
-        expect(defined?(WDM)).to be_true
-      end
-    end
-  end
-
-  if darwin?
-    it "isn't usable on Darwin" do
-      expect(described_class).to_not be_usable
-    end
-  end
-
-  if linux?
-    it "isn't usable on Linux" do
-      expect(described_class).to_not be_usable
-    end
-  end
-
-  if bsd?
-    it "isn't usable on BSD" do
-      expect(described_class).to_not be_usable
+    if windows?
+      it { should be_usable }
+    else
+      it { should_not be_usable }
     end
   end
-
-  specify { expect(described_class).to be_local_fs }
-
 end

data/spec/lib/listen/adapter_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe Listen::Adapter do
 
-  let(:listener) { double(Listen::Listener, options: {}) }
+  let(:listener) { instance_double(Listen::Listener, options: {}) }
   before do
-    Listen::Adapter::BSD.stub(:usable?) { false }
-    Listen::Adapter::Darwin.stub(:usable?) { false }
-    Listen::Adapter::Linux.stub(:usable?) { false }
-    Listen::Adapter::Windows.stub(:usable?) { false }
+    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
@@ -22,31 +22,31 @@ describe Listen::Adapter do
     end
 
     it 'returns BSD adapter when usable' do
-      Listen::Adapter::BSD.stub(:usable?) { true }
+      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
-      Listen::Adapter::Darwin.stub(:usable?) { true }
+      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
-      Listen::Adapter::Linux.stub(:usable?) { true }
+      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
-      Listen::Adapter::Windows.stub(:usable?) { true }
+      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 { Kernel.stub(:warn) }
+      before { allow(Kernel).to receive(:warn) }
 
       it 'returns Polling adapter' do
         klass = Listen::Adapter.select(force_polling: true)

data/spec/lib/listen/change_spec.rb

@@ -1,111 +1,109 @@
 require 'spec_helper'
 
 describe Listen::Change do
-  let(:change) { Listen::Change.new(listener) }
-  let(:registry) { double(Celluloid::Registry) }
-  let(:listener) { double(Listen::Listener, registry: registry, options: {}) }
-  let(:listener_changes) { double('listener_changes') }
+  let(:subject) { Listen::Change.new(listener) }
+  let(:listener) { instance_double(Listen::Listener, options: {}) }
+  let(:record) { instance_double(Listen::Record) }
+  let(:file_path) { Pathname.new('file_path') }
+
   before do
-    listener.stub(:changes) { listener_changes }
+    allow(listener).to receive(:sync).with(:record) { record }
+    allow(listener).to receive(:async).with(:change_pool) { subject }
   end
 
   describe '#change' do
-    let(:silencer) { double('Listen::Silencer', silenced?: false) }
-    before { registry.stub(:[]).with(:silencer) { silencer } }
+    let(:silencer) { instance_double(Listen::Silencer, silenced?: false) }
+    before { allow(listener).to receive(:silencer) { silencer } }
+
+    context 'with build options' do
+      let(:async_record) do
+        instance_double(Listen::Record, still_building!: nil)
+      end
 
-    context 'file path' do
+      it 'calls update_last_build_time on record' do
+        allow(listener).to receive(:queue)
+        allow(record).to receive(:async) { async_record }
+        expect(async_record).to receive(:unset_path)
+        subject.change(:file, file_path, build: true)
+      end
+    end
+
+    context 'file' do
       context 'with known change' do
+        let(:file_path) { Pathname('file_path') }
         it 'notifies change directly to listener' do
-          expect(listener_changes).to receive(:<<).
-            with(modified: Pathname.new('file_path'))
+          expect(listener).to receive(:queue).
+            with(:file, :modified, file_path, {})
 
-          options = { type: 'File', change: :modified }
-          change.change(Pathname.new('file_path'), options)
+          subject.change(:file, file_path, change: :modified)
         end
 
         it "doesn't notify to listener if path is silenced" do
           expect(silencer).to receive(:silenced?).and_return(true)
-          expect(listener_changes).to_not receive(:<<)
-
-          options = { type: 'File', change: :modified }
-          change.change(Pathname.new('file_path'), options)
+          expect(listener).to_not receive(:queue)
+          subject.change(:file, file_path, change: :modified)
         end
       end
 
       context 'with unknown change' do
-        let(:file) { double('Listen::File') }
-        before { Listen::File.stub(:new) { file } }
 
         it 'calls Listen::File#change' do
-          expect(Listen::File).to receive(:new).
-            with(listener, Pathname.new('file_path')) { file }
-
-          expect(file).to receive(:change)
-          change.change(Pathname.new('file_path'), type: 'File')
+          expect(Listen::File).to receive(:change).with(record, file_path)
+          subject.change(:file, file_path)
         end
 
         it "doesn't call Listen::File#change if path is silenced" do
           expect(silencer).to receive(:silenced?).
-            with(Pathname.new('file_path'), 'File').and_return(true)
-
-          expect(Listen::File).to_not receive(:new)
+            with(file_path, :file).and_return(true)
 
-          change.change(Pathname.new('file_path'), type: 'File')
+          expect(Listen::File).to_not receive(:change)
+          subject.change(:file, file_path)
         end
 
         context 'that returns a change' do
-          before { file.stub(:change) { :modified } }
+          before { allow(Listen::File).to receive(:change) { :modified } }
 
           context 'listener listen' do
-            before { listener.stub(:listen?) { true } }
-
             it 'notifies change to listener' do
-              file_path = double(Pathname, to_s: 'file_path', exist?: true)
-              expect(listener_changes).to receive(:<<).with(modified: file_path)
-              change.change(file_path, type: 'File')
+              file_path = instance_double(Pathname,
+                                          to_s: 'file_path',
+                                          exist?: true)
+
+              expect(listener).to receive(:queue).
+                with(:file, :modified, file_path)
+
+              subject.change(:file, file_path)
             end
 
             context 'silence option' do
               it 'notifies change to listener' do
-                expect(listener_changes).to_not receive(:<<)
-                options = { type: 'File', silence: true }
-                change.change(Pathname.new('file_path'), options)
+                expect(listener).to_not receive(:queue)
+                subject.change(:file, file_path, silence: true)
               end
             end
           end
-
-          context "listener doesn't listen" do
-            before { listener.stub(:listen?) { false } }
-
-            it 'notifies change to listener' do
-              expect(listener_changes).to_not receive(:<<)
-              change.change(Pathname.new('file_path'), type: 'File')
-            end
-          end
         end
 
         context 'that returns no change' do
-          before { file.stub(:change) { nil } }
+          before { allow(Listen::File).to receive(:change) { nil } }
 
           it "doesn't notifies no change" do
-            expect(listener_changes).to_not receive(:<<)
-            change.change(Pathname.new('file_path'), type: 'File')
+            expect(listener).to_not receive(:queue)
+            subject.change(:file, file_path)
           end
         end
       end
     end
 
-    context 'directory path' do
-      let(:dir) { double(Listen::Directory) }
-      let(:dir_options) { { type: 'Dir', recursive: true } }
-      before { Listen::Directory.stub(:new) { dir } }
+    context 'directory' do
+      let(:dir_options) { { recursive: true } }
+      let(:dir_path) { Pathname.new('dir_path') }
 
-      it 'calls Listen::Directory#scan' do
-        expect(Listen::Directory).to receive(:new).
-          with(listener, Pathname.new('dir_path'), dir_options) { dir }
+      it 'calls Listen::Directory#new' do
+        expect(Listen::Directory).to receive(:scan).
+          with(subject, record, dir_path, dir_options)
 
-        expect(dir).to receive(:scan)
-        change.change(Pathname.new('dir_path'), dir_options)
+        subject.change(:dir, dir_path, dir_options)
       end
     end
   end

data/spec/lib/listen/directory_spec.rb

@@ -1,212 +1,162 @@
 require 'spec_helper'
 
-describe Listen::Directory do
-  let(:registry) { double(Celluloid::Registry) }
-  let(:listener) { double(Listen::Listener, registry: registry, options: {}) }
+include Listen
 
-  let(:record) do
-    double(Listen::Record, async: double(set_path: true, unset_path: true))
-  end
+describe Directory do
+  let(:path) { Pathname.pwd }
+  let(:dir) { path + 'dir' }
+  let(:file) { dir + 'file.rb' }
+  let(:file2) { dir + 'file2.rb' }
+  let(:subdir) { dir + 'subdir' }
+  let(:subdir2) { instance_double(Pathname, directory?: true) }
 
-  let(:change_pool) { double(Listen::Change) }
-  let(:change_pool_async) { double('ChangePoolAsync') }
-  let(:path) { Pathname.new(Dir.pwd) }
-  around { |example| fixtures { example.run } }
-  before do
-    change_pool.stub(:async) { change_pool_async }
-    registry.stub(:[]).with(:record) { record }
-    registry.stub(:[]).with(:change_pool) { change_pool }
+  let(:queue) { instance_double(Change, change: nil) }
+
+  let(:async_record) do
+    instance_double(Record, set_path: true, unset_path: true)
   end
 
-  describe '#scan' do
-    let(:dir_path) { path.join('dir') }
-    let(:file_path) { dir_path.join('file.rb') }
-    let(:other_file_path) { dir_path.join('other_file.rb') }
-    let(:inside_dir_path) { dir_path.join('inside_dir') }
-    let(:other_inside_dir_path) { dir_path.join('other_inside_dir') }
-    let(:dir) { Listen::Directory.new(listener, dir_path, options) }
-
-    context 'with recursive off' do
-      let(:options) { { recursive: false } }
-
-      context 'file & inside_dir paths present in record' do
-        let(:record_dir_entries) do
-          {
-            'file.rb' => { type: 'File' },
-            'inside_dir' => { type: 'Dir' }
-          }
-        end
+  let(:record) do
+    instance_double(Record, async: async_record, dir_entries: record_entries)
+  end
 
-        before do
-          record.stub_chain(:future, :dir_entries) do
-            double(value: record_dir_entries)
-          end
+  context '#scan with recursive off' do
+    let(:options) { { recursive: false } }
 
-          change_pool_async.stub(:change)
-        end
+    context 'with file & subdir in record' do
+      let(:record_entries) do
+        { 'file.rb' => { type: :file }, 'subdir' => { type: :dir } }
+      end
 
-        context 'empty dir' do
-          around do |example|
-            mkdir dir_path
-            example.run
-          end
+      context 'with empty dir' do
+        before { allow(dir).to receive(:children) { [] } }
 
-          it 'sets record dir path' do
-            expect(record.async).to receive(:set_path).
-              with(dir_path, type: 'Dir')
-            dir.scan
-          end
+        it 'sets record dir path' do
+          expect(async_record).to receive(:set_path).with(:dir, dir)
+          described_class.scan(queue, record, dir, options)
+        end
 
-          it "calls change for file path and dir that doesn't exist" do
-            expect(change_pool_async).to receive(:change).
-              with(file_path, type: 'File', recursive: false)
+        it "queues changes for file path and dir that doesn't exist" do
+          expect(queue).to receive(:change).with(:file, file)
 
-            expect(change_pool_async).to receive(:change).
-              with(inside_dir_path, type: 'Dir', recursive: false)
+          expect(queue).to receive(:change).
+            with(:dir, subdir, recursive: false)
 
-            dir.scan
-          end
+          described_class.scan(queue, record, dir, options)
         end
+      end
 
-        context 'other file path present in dir' do
-          around do |example|
-            mkdir dir_path
-            touch other_file_path
-            example.run
-          end
-
-          it 'notices file & other_file and no longer existing dir' do
-            expect(change_pool_async).to receive(:change).
-              with(file_path, type: 'File', recursive: false)
+      context 'with file2.rb in dir' do
+        before { allow(dir).to receive(:children) { [file2] } }
 
-            expect(change_pool_async).to receive(:change).
-              with(other_file_path, type: 'File', recursive: false)
+        it 'notices file & file2 and no longer existing dir' do
+          expect(queue).to receive(:change).with(:file, file)
+          expect(queue).to receive(:change).with(:file, file2)
 
-            expect(change_pool_async).to receive(:change).
-              with(inside_dir_path, type: 'Dir', recursive: false)
+          expect(queue).to receive(:change).
+            with(:dir, subdir, recursive: false)
 
-            dir.scan
-          end
+          described_class.scan(queue, record, dir, options)
         end
       end
+    end
 
-      context 'dir paths not present in record' do
-        before do
-          record.stub_chain(:future, :dir_entries) { double(value: {}) }
-        end
+    context 'with empty record' do
+      let(:record_entries) { {} }
 
-        context 'non-existing dir path' do
-          it 'calls change only for file path' do
-            expect(change_pool_async).to_not receive(:change)
-            dir.scan
-          end
+      context 'with non-existing dir path' do
+        before { allow(dir).to receive(:children) { fail Errno::ENOENT } }
 
-          it 'unsets record dir path' do
-            expect(record.async).to receive(:unset_path).with(dir_path)
-            dir.scan
-          end
+        it 'reports no changes' do
+          expect(queue).to_not receive(:change)
+          described_class.scan(queue, record, dir, options)
         end
 
-        context 'other file path present in dir' do
-          around do |example|
-            mkdir dir_path
-            touch file_path
-            example.run
-          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
 
-          it 'calls change for file & other_file paths' do
-            expect(change_pool_async).to receive(:change).
-              with(file_path, type: 'File', recursive: false)
+      context 'with file.rb in dir' do
+        before { allow(dir).to receive(:children) { [file] } }
 
-            expect(change_pool_async).to_not receive(:change).
-              with(other_file_path, type: 'File', recursive: false)
+        it 'queues changes for file & file2 paths' do
+          expect(queue).to receive(:change).with(:file, file)
+          expect(queue).to_not receive(:change).with(:file, file2)
 
-            expect(change_pool_async).to_not receive(:change).
-              with(inside_dir_path, type: 'Dir', recursive: false)
+          expect(queue).to_not receive(:change).
+            with(:dir, subdir, recursive: false)
 
-            dir.scan
-          end
+          described_class.scan(queue, record, dir, options)
         end
       end
     end
+  end
 
-    context 'with recursive on' do
-      let(:options) { { recursive: true } }
+  context '#scan with recursive on' do
+    let(:options) { { recursive: true } }
 
-      context 'file & inside_dir paths present in record' do
-        let(:record_dir_entries) do {
-          'file.rb' => { type: 'File' },
-          'inside_dir' => { type: 'Dir' } }
-        end
+    context 'with file.rb & subdir in record' do
+      let(:record_entries) do
+        { 'file.rb' => { type: :file }, 'subdir' => { type: :dir } }
+      end
 
-        before do
-          record.stub_chain(:future, :dir_entries) do
-            double(value: record_dir_entries)
-          end
-        end
+      context 'with empty dir' do
+        before { allow(dir).to receive(:children) { [] } }
 
-        context 'empty dir' do
-          it 'calls change for file & inside_dir path' do
-            expect(change_pool_async).to receive(:change).
-              with(file_path, type: 'File', recursive: true)
+        it 'queues changes for file & subdir path' do
+          expect(queue).to receive(:change).with(:file, file)
 
-            expect(change_pool_async).to receive(:change).
-              with(inside_dir_path, type: 'Dir', recursive: true)
+          expect(queue).to receive(:change).
+            with(:dir, subdir, recursive: true)
 
-            dir.scan
-          end
+          described_class.scan(queue, record, dir, options)
         end
+      end
 
-        context 'other inside_dir path present in dir' do
-          around do |example|
-            mkdir dir_path
-            mkdir other_inside_dir_path
-            example.run
-          end
+      context 'with subdir2 path present in dir' do
+        before do
+          allow(path).to receive(:children) { [dir] }
+          allow(dir).to receive(:children) { [subdir2] }
+        end
 
-          it 'calls change for file, other_file & inside_dir paths' do
-            expect(change_pool_async).to receive(:change).
-              with(file_path, type: 'File', recursive: true)
+        it 'queues changes for file, file2 & subdir paths' do
+          expect(queue).to receive(:change).with(:file, file)
 
-            expect(change_pool_async).to receive(:change).
-              with(inside_dir_path, type: 'Dir', recursive: true)
+          expect(queue).to receive(:change).
+            with(:dir, subdir, recursive: true)
 
-            expect(change_pool_async).to receive(:change).
-              with(other_inside_dir_path, type: 'Dir', recursive: true)
+          expect(queue).to receive(:change).
+            with(:dir, subdir2, recursive: true)
 
-            dir.scan
-          end
+          described_class.scan(queue, record, dir, options)
         end
       end
+    end
 
-      context 'dir paths not present in record' do
-        before do
-          record.stub_chain(:future, :dir_entries) { double(value: {}) }
-        end
+    context 'with empty record' do
+      let(:record_entries) { {} }
 
-        context 'non-existing dir path' do
-          it 'calls change only for file path' do
-            expect(change_pool_async).to_not receive(:change)
-            dir.scan
-          end
+      context 'with non-existing dir' 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
+      end
 
-        context 'other file path present in dir' do
-          around do |example|
-            mkdir dir_path
-            mkdir other_inside_dir_path
-            example.run
-          end
+      context 'with subdir2 present in dir' do
+        before { allow(dir).to receive(:children) { [subdir2] } }
 
-          it 'calls change for file & other_file paths' do
-            expect(change_pool_async).to receive(:change).
-              with(other_inside_dir_path, type: 'Dir', recursive: true)
+        it 'queues changes for file & file2 paths' do
+          expect(queue).to receive(:change).
+            with(:dir, subdir2, recursive: true)
 
-            dir.scan
-          end
+          described_class.scan(queue, record, dir, options)
         end
       end
     end
   end
-
 end