listen 2.7.6 → 2.7.7

data/spec/lib/listen/listener_spec.rb

@@ -1,21 +1,25 @@
 require 'spec_helper'
 
-describe Listen::Listener do
+include Listen
+
+describe Listener do
   subject { described_class.new(options) }
   let(:options) { {} }
-  let(:registry) { instance_double(Celluloid::Registry, :[]= => true) }
+  let(:registry) { instance_double(Celluloid::Registry) }
 
   let(:supervisor) do
     instance_double(Celluloid::SupervisionGroup, add: true, pool: true)
   end
 
-  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) }
+  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(:silencer) { silencer }
     allow(registry).to receive(:[]).with(:adapter) { adapter }
     allow(registry).to receive(:[]).with(:record) { record }
   end
@@ -75,31 +79,25 @@ describe Listen::Listener do
       allow(silencer).to receive(:silenced?) { false }
     end
 
-    it 'registers silencer' do
-      expect(supervisor).to receive(:add).
-        with(Listen::Silencer, as: :silencer, args: subject)
-
-      subject.start
-    end
-
     it 'supervises change_pool' do
       expect(supervisor).to receive(:pool).
-        with(Listen::Change, as: :change_pool, args: subject)
+        with(Change, as: :change_pool, args: subject)
 
       subject.start
     end
 
     it 'supervises adaper' do
-      allow(Listen::Adapter).to receive(:select) { Listen::Adapter::Polling }
+      allow(Adapter).to receive(:select) { Adapter::Polling }
+      options = [mq: subject, directories: []]
       expect(supervisor).to receive(:add).
-        with(Listen::Adapter::Polling, as: :adapter, args: subject)
+        with(Adapter::Polling, as: :adapter, args: options)
 
       subject.start
     end
 
     it 'supervises record' do
       expect(supervisor).to receive(:add).
-        with(Listen::Record, as: :record, args: subject)
+        with(Record, as: :record, args: subject)
 
       subject.start
     end
@@ -122,11 +120,14 @@ describe Listen::Listener do
     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, foo)
+      subject.queue(:file, :modified, dir, 'foo')
       sleep 0.25
     end
   end
@@ -199,20 +200,11 @@ describe Listen::Listener do
   end
 
   describe '#ignore' do
-    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(subject) { new_silencer }
-      expect(registry).to receive(:[]=).with(:silencer, new_silencer)
-      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(subject)
+        expect(silencer).to receive(:configure).with(options)
         subject.ignore(/foo/)
         expect(subject.options).to include(ignore: [/bar/, /foo/])
       end
@@ -222,7 +214,7 @@ describe Listen::Listener do
       let(:options) { { ignore: [/bar/] } }
 
       it 'adds up to existing ignore options' do
-        expect(Listen::Silencer).to receive(:new).with(subject)
+        expect(silencer).to receive(:configure).with(options)
         subject.ignore(/foo/)
         expect(subject.options).to include(ignore: [[/bar/], /foo/])
       end
@@ -230,21 +222,20 @@ describe Listen::Listener do
   end
 
   describe '#ignore!' do
-    let(:new_silencer) { instance_double(Listen::Silencer) }
-    before { allow(Celluloid::Actor).to receive(:[]=) }
+    context 'with no existing options' do
+      let(:options) { {} }
 
-    it 'resets silencer actor' do
-      expect(Listen::Silencer).to receive(:new).with(subject) { new_silencer }
-      expect(registry).to receive(:[]=).with(:silencer, new_silencer)
-      subject.ignore!(/foo/)
-      expect(subject.options).to include(ignore!: /foo/)
+      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(Listen::Silencer).to receive(:new).with(subject)
+        expect(silencer).to receive(:configure).with(options)
         subject.ignore!([/foo/])
         expect(subject.options).to include(ignore!: [/foo/])
       end
@@ -254,7 +245,7 @@ describe Listen::Listener do
       let(:options) { { ignore: /bar/ } }
 
       it 'deletes ignore options' do
-        expect(Listen::Silencer).to receive(:new).with(subject)
+        expect(silencer).to receive(:configure).with(options)
         subject.ignore!([/foo/])
         expect(subject.options).to_not include(ignore: /bar/)
       end
@@ -262,20 +253,11 @@ describe Listen::Listener do
   end
 
   describe '#only' do
-    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(subject) { new_silencer }
-      expect(registry).to receive(:[]=).with(:silencer, new_silencer)
-      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(subject)
+        expect(silencer).to receive(:configure).with(options)
         subject.only([/foo/])
         expect(subject.options).to include(only: [/foo/])
       end
@@ -287,60 +269,69 @@ describe Listen::Listener do
       allow(silencer).to receive(:silenced?) { false }
 
       subject.block = proc do |modified, added, _|
-        expect(modified).to eql(['foo.txt'])
-        expect(added).to eql(['bar.txt'])
+        expect(modified).to eql(['foo/bar.txt'])
+        expect(added).to eql(['foo/baz.txt'])
       end
 
-      foo = instance_double(
+      bar = instance_double(
         Pathname,
-        to_s: 'foo.txt',
+        to_s: 'foo/bar.txt',
         exist?: true,
         directory?: false)
 
-      bar = instance_double(
+      baz = instance_double(
         Pathname,
-        to_s: 'bar.txt',
+        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, foo, {})
-      subject.queue(:file, :added, bar, {})
+      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
-      path = instance_double(
+      bar = instance_double(
         Pathname,
-        to_s: 'foo',
+        to_s: 'bar',
         exist?: true,
         directory?: false)
 
+      foo = instance_double(Pathname, to_s: 'foo')
+      allow(foo).to receive(:+).with('bar') { bar }
+
       changes = [
-        [:file, :modified, path],
-        [:file, :removed, path],
-        [:file, :added, path],
-        [:file, :modified, path]
+        [: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: ['foo'], added: [], removed: [])
+      expect(smooshed).to eq(modified: ['bar'], added: [], removed: [])
     end
 
-    it 'recognizes deleted temp file' do
-      path = instance_double(
+    it 'ignores deleted temp file' do
+      bar = instance_double(
         Pathname,
-        to_s: 'foo',
-        exist?: false,
-        directory?: false)
+        to_s: 'bar',
+        exist?: false)
+
+      foo = instance_double(Pathname, to_s: 'foo')
+      allow(foo).to receive(:+).with('bar') { bar }
 
       changes = [
-        [:file, :added, path],
-        [:file, :modified, path],
-        [:file, :removed, path],
-        [:file, :modified, path]
+        [: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
@@ -349,19 +340,21 @@ describe Listen::Listener do
 
     it 'recognizes double move as modification' do
       # e.g. "mv foo x && mv x foo" is like "touch foo"
-      path = instance_double(
+      bar = instance_double(
         Pathname,
-        to_s: 'foo',
-        exist?: true,
-        directory?: false)
+        to_s: 'bar',
+        exist?: true)
+
+      dir = instance_double(Pathname, to_s: 'foo')
+      allow(dir).to receive(:+).with('bar') { bar }
 
       changes = [
-        [:file, :removed, path],
-        [:file, :added, path]
+        [: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: ['foo'], added: [], removed: [])
+      expect(smooshed).to eq(modified: ['bar'], added: [], removed: [])
     end
 
     context 'with cookie' do
@@ -370,11 +363,15 @@ describe Listen::Listener do
         foo = instance_double(
           Pathname,
           to_s: 'foo',
-          exist?: true,
-          directory?: false)
+          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 }
 
-        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
@@ -392,15 +389,21 @@ describe Listen::Listener do
           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, foo , cookie: 4321],
-          [:file, :moved_to, bar, cookie: 4321]
+          [:file, :moved_from, dir, 'foo', cookie: 4321],
+          [:file, :moved_to, dir, 'bar', cookie: 4321]
         ]
 
         expect(silencer).to receive(:silenced?).
-          twice.with(foo, :file) { false }
+          twice.with(Pathname('foo'), :file) { false }
+
+        expect(silencer).to receive(:silenced?).
+          with(Pathname('bar'), :file) { false }
 
-        expect(silencer).to receive(:silenced?).with(bar, :file) { false }
         smooshed = subject.send :_smoosh_changes, changes
         expect(smooshed).to eq(modified: [], added: ['bar'], removed: [])
       end
@@ -410,7 +413,7 @@ describe Listen::Listener do
 
         ignored = instance_double(
           Pathname,
-          to_s: 'foo',
+          to_s: 'ignored',
           exist?: true,
           directory?: false)
 
@@ -420,26 +423,60 @@ describe Listen::Listener do
           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, ignored, cookie: 4321],
-          [:file, :moved_to, foo , cookie: 4321]
+          [:file, :moved_from, dir, 'ignored', cookie: 4321],
+          [:file, :moved_to, dir, 'foo' , cookie: 4321]
         ]
-        expect(silencer).to receive(:silenced?).with(ignored, :file) { true }
-        expect(silencer).to receive(:silenced?).with(foo, :file) { false }
+
+        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
-      it 'recognizes properly ignores files' do
-        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: [])
+      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

data/spec/lib/listen/record_spec.rb

@@ -8,127 +8,270 @@ describe Listen::Record do
   end
 
   let(:record) { Listen::Record.new(listener) }
-  let(:path) { '/dir/path/file.rb' }
+  let(:dir) { instance_double(Pathname, to_s: '/dir') }
 
-  describe '#set_path' do
-    it 'sets path by spliting dirname and basename' do
-      record.set_path(:file, path)
-      expect(record.paths['/dir/path']).to eq('file.rb' => { type: :file })
+  describe '#update_file' do
+    context 'with path in watched dir' do
+      it 'sets path by spliting dirname and basename' do
+        record.update_file(dir, 'file.rb', mtime: 1.1)
+        expect(record.paths['/dir']).to eq('file.rb' => { mtime: 1.1 })
+      end
+
+      it 'sets path and keeps old data not overwritten' do
+        record.update_file(dir, 'file.rb', foo: 1, bar: 2)
+        record.update_file(dir, 'file.rb', foo: 3)
+        watched_dir = record.paths['/dir']
+        expect(watched_dir).to eq('file.rb' => { foo: 3, bar: 2 })
+      end
+    end
+
+    context 'with subdir path' do
+      it 'sets path by spliting dirname and basename' do
+        record.update_file(dir, 'path/file.rb', mtime: 1.1)
+        expect(record.paths['/dir']['path']).to eq('file.rb' => { mtime: 1.1 })
+      end
+
+      it 'sets path and keeps old data not overwritten' do
+        record.update_file(dir, 'path/file.rb', foo: 1, bar: 2)
+        record.update_file(dir, 'path/file.rb', foo: 3)
+        file_data = record.paths['/dir']['path']['file.rb']
+        expect(file_data).to eq(foo: 3, bar: 2)
+      end
+    end
+  end
+
+  describe '#add_dir' do
+    it 'sets itself when .' do
+      record.add_dir(dir, '.')
+      expect(record.paths['/dir']).to eq({})
+    end
+
+    it 'sets itself when nil' do
+      record.add_dir(dir, nil)
+      expect(record.paths['/dir']).to eq({})
+    end
+
+    it 'sets itself when empty' do
+      record.add_dir(dir, '')
+      expect(record.paths['/dir']).to eq({})
+    end
+
+    it 'correctly sets new directory data' do
+      record.add_dir(dir, 'path/subdir')
+      expect(record.paths['/dir']).to eq('path/subdir' => {})
     end
 
     it 'sets path and keeps old data not overwritten' do
-      record.set_path(:file, path, foo: 1, bar: 2)
-      record.set_path(:file, path, foo: 3)
-      file_data = record.paths['/dir/path']['file.rb']
-      expect(file_data).to eq(foo: 3, bar: 2, type: :file)
+      record.add_dir(dir, 'path/subdir')
+      record.update_file(dir, 'path/subdir/file.rb', mtime: 1.1)
+      record.add_dir(dir, 'path/subdir')
+      record.update_file(dir, 'path/subdir/file2.rb', mtime: 1.2)
+      record.add_dir(dir, 'path/subdir')
+
+      watched = record.paths['/dir']
+      expect(watched.keys).to eq ['path/subdir']
+      expect(watched['path/subdir'].keys).to eq %w(file.rb file2.rb)
+
+      subdir = watched['path/subdir']
+      expect(subdir['file.rb']).to eq(mtime: 1.1)
+      expect(subdir['file2.rb']).to eq(mtime: 1.2)
     end
   end
 
   describe '#unset_path' do
     context 'path is present' do
-      before { record.set_path(:file, path) }
+      before { record.update_file(dir, 'path/file.rb', mtime: 1.1) }
 
       it 'unsets path' do
-        record.unset_path(path)
-        expect(record.paths).to eq('/dir/path' => {})
+        record.unset_path(dir, 'path/file.rb')
+        expect(record.paths).to eq('/dir' => { 'path' => {} })
       end
     end
 
     context 'path not present' do
       it 'unsets path' do
-        record.unset_path(path)
-        expect(record.paths).to eq('/dir/path' => {})
+        record.unset_path(dir, 'path/file.rb')
+        expect(record.paths).to eq('/dir' => { 'path' => {} })
       end
     end
   end
 
   describe '#file_data' do
-    context 'path is present' do
-      before { record.set_path(:file, path) }
+    context 'with path in watched dir' do
+      context 'when path is present' do
+        before { record.update_file(dir, 'file.rb', mtime: 1.1) }
 
-      it 'returns file data' do
-        expect(record.file_data(path)).to eq(type: :file)
+        it 'returns file data' do
+          expect(record.file_data(dir, 'file.rb')).to eq(mtime: 1.1)
+        end
+      end
+
+      context 'path not present' do
+        it 'return empty hash' do
+          expect(record.file_data(dir, 'file.rb')).to be_empty
+        end
       end
     end
 
-    context 'path not present' do
-      it 'return empty hash' do
-        expect(record.file_data(path)).to be_empty
+    context 'with path in subdir' do
+      context 'when path is present' do
+        before { record.update_file(dir, 'path/file.rb', mtime: 1.1) }
+
+        it 'returns file data' do
+          expected = { mtime: 1.1 }
+          expect(record.file_data(dir, 'path/file.rb')).to eq expected
+        end
+      end
+
+      context 'path not present' do
+        it 'return empty hash' do
+          expect(record.file_data(dir, 'path/file.rb')).to be_empty
+        end
       end
     end
   end
 
   describe '#dir_entries' do
-    context 'path is present' do
-      before { record.set_path(:file, path) }
+    context 'in watched dir' do
+      subject { record.dir_entries(dir, '.') }
+
+      context 'with no entries' do
+        it { should be_empty }
+      end
+
+      context 'with file.rb in record' do
+        before { record.update_file(dir, 'file.rb', mtime: 1.1) }
+        it { should eq('file.rb' => { mtime: 1.1 }) }
+        context 'when file is removed' do
+          before { record.update_file(dir, 'file.rb', mtime: 1.1) }
+        end
+      end
 
-      it 'returns file path' do
-        entries = record.dir_entries('/dir/path')
-        expect(entries).to eq('file.rb' => { type: :file })
+      context 'with subdir/file.rb in record' do
+        before { record.update_file(dir, 'subdir/file.rb', mtime: 1.1) }
+        it { should eq('subdir' => {}) }
       end
     end
 
-    context 'path not present' do
-      it 'unsets path' do
-        expect(record.dir_entries('/dir/path')).to eq({})
+    context 'in subdir /path' do
+      subject { record.dir_entries(dir, 'path') }
+
+      context 'with no entries' do
+        it { should be_empty }
+      end
+
+      context 'with path/file.rb already in record' do
+        before { record.update_file(dir, 'path/file.rb', mtime: 1.1) }
+        it { should eq('file.rb' => { mtime: 1.1 }) }
       end
     end
   end
 
   describe '#build' do
-    let(:directories) { ['dir_path'] }
+    let(:dir1) { Pathname('/dir1') }
+    let(:dir2) { Pathname('/dir2') }
 
-    let(:actor) do
-      instance_double(Listen::Change, change: nil, terminate: true)
-    end
+    let(:directories) { [dir1, dir2]  }
 
     before do
       allow(listener).to receive(:directories) { directories }
-      allow(listener).to receive(:sync).with(:change_pool) { actor }
+
+      allow(::File).to receive(:lstat) do |path|
+        fail "::File.lstat stub called with: #{path.inspect}"
+      end
+
+      allow(::Dir).to receive(:entries) do |path|
+        fail "::Dir.entries stub called with: #{path.inspect}"
+      end
+
+      allow(::Dir).to receive(:exist?) do |path|
+        fail "::Dir.exist? stub called with: #{path.inspect}"
+      end
     end
 
     it 're-inits paths' do
-      record.set_path(:file, path)
-      record.build
-      expect(record.file_data(path)).to be_empty
-    end
+      allow(::Dir).to receive(:entries) { [] }
 
-    it 'calls change asynchronously on all directories to build record'  do
-      expect(actor).to receive(:change).
-        with(:dir, 'dir_path', recursive: true, silence: true, build: true)
+      record.update_file(dir, 'path/file.rb', mtime: 1.1)
       record.build
+      expect(record.paths).to eq('/dir1' => {}, '/dir2' => {})
+      expect(record.file_data(dir, 'path/file.rb')).to be_empty
     end
-  end
 
-  describe '#still_building!' do
-    let(:directories) { ['dir_path'] }
+    let(:foo_stat) { instance_double(::File::Stat, mtime: 1.0, mode: 0644) }
+    let(:bar_stat) { instance_double(::File::Stat, mtime: 2.3, mode: 0755) }
 
-    let(:actor) do
-      instance_double(Listen::Change, change: nil, terminate: true)
-    end
+    context 'with no subdirs' do
 
-    before do
-      allow(listener).to receive(:directories) { directories }
-      allow(listener).to receive(:sync).with(:change_pool) { actor }
+      before do
+        expect(::Dir).to receive(:entries).with('/dir1/.') { %w(foo bar) }
+        expect(::Dir).to receive(:exist?).with('/dir1/./foo') { false }
+        expect(::Dir).to receive(:exist?).with('/dir1/./bar') { false }
+        expect(::File).to receive(:lstat).with('/dir1/./foo') { foo_stat }
+        expect(::File).to receive(:lstat).with('/dir1/./bar') { bar_stat }
+
+        expect(::Dir).to receive(:entries).with('/dir2/.') { [] }
+      end
+
+      it 'builds record'  do
+        record.build
+        expect(record.paths.keys).to eq %w( /dir1 /dir2 )
+        expect(record.paths['/dir1']).
+          to eq(
+            'foo' => { mtime: 1.0, mode: 0644 },
+            'bar' => { mtime: 2.3, mode: 0755 })
+      end
     end
 
-    it 'keeps the build blocking longer' do
-      record # To avoid initializing record in thread
+    context 'with subdir containing files' do
+      before do
+        expect(::Dir).to receive(:entries).with('/dir1/.') { %w(foo) }
+        expect(::Dir).to receive(:exist?).with('/dir1/./foo') { true }
 
-      th = Thread.new do
-        10.times do
-          sleep 0.05
-          record.still_building!
-        end
+        expect(::Dir).to receive(:entries).with('/dir1/foo') { %w(bar) }
+
+        expect(::Dir).to receive(:exist?).with('/dir1/foo/bar') { false }
+        expect(::File).to receive(:lstat).with('/dir1/foo/bar') { bar_stat }
+
+        expect(::Dir).to receive(:entries).with('/dir2/.') { [] }
       end
 
-      started = Time.now
-      record.build
-      ended  = Time.now
+      it 'builds record'  do
+        record.build
+        expect(record.paths.keys).to eq %w( /dir1 /dir2 )
+        expect(record.paths['/dir1']).
+          to eq('foo' => { 'bar' => { mtime: 2.3, mode: 0755 } })
+        expect(record.paths['/dir2']).to eq({})
+      end
+    end
+
+    context 'with subdir containing dirs' do
+      before do
+        expect(::Dir).to receive(:entries).with('/dir1/.') { %w(foo) }
+        expect(::Dir).to receive(:exist?).with('/dir1/./foo') { true }
+
+        expect(::Dir).to receive(:entries).with('/dir1/foo') { %w(bar baz) }
 
-      th.join
+        expect(::Dir).to receive(:exist?).with('/dir1/foo/bar') { true }
+        expect(::Dir).to receive(:entries).with('/dir1/foo/bar') { [] }
 
-      expect(ended - started).to be > 0.5
+        expect(::Dir).to receive(:exist?).with('/dir1/foo/baz') { true }
+        expect(::Dir).to receive(:entries).with('/dir1/foo/baz') { [] }
+
+        expect(::Dir).to receive(:entries).with('/dir2/.') { [] }
+      end
+
+      it 'builds record'  do
+        record.build
+        expect(record.paths.keys).to eq %w( /dir1 /dir2 )
+        expect(record.paths['/dir1']).
+          to eq(
+            'foo' => {},
+            'foo/bar' => {},
+            'foo/baz' => {},
+        )
+        expect(record.paths['/dir2']).to eq({})
+      end
     end
   end
 end