memfs 0.4.3 → 0.5.0

data/spec/memfs/dir_spec.rb

@@ -2,56 +2,54 @@ require 'spec_helper'
 
 module MemFs
   describe Dir do
-    subject { MemFs::Dir }
+    subject { described_class.new('/test') }
 
-    let(:instance) { MemFs::Dir.new('/test') }
-
-    before { subject.mkdir '/test' }
+    before { described_class.mkdir '/test' }
 
     it 'is Enumerable' do
-      expect(instance).to be_an(Enumerable)
+      expect(subject).to be_an(Enumerable)
     end
 
     describe '[]' do
       context 'when a string is given' do
         it 'acts like calling glob' do
-          expect(subject['/*']).to eq %w[/tmp /test]
+          expect(described_class['/*']).to eq %w[/tmp /test]
         end
       end
 
       context 'when a list of strings is given' do
         it 'acts like calling glob' do
-          expect(subject['/tm*', '/te*']).to eq %w[/tmp /test]
+          expect(described_class['/tm*', '/te*']).to eq %w[/tmp /test]
         end
       end
     end
 
     describe '.chdir' do
       it 'changes the current working directory' do
-        subject.chdir '/test'
-        expect(subject.getwd).to eq('/test')
+        described_class.chdir '/test'
+        expect(described_class.getwd).to eq('/test')
       end
 
       it 'returns zero' do
-        expect(subject.chdir('/test')).to be_zero
+        expect(described_class.chdir('/test')).to be_zero
       end
 
       it 'raises an error when the folder does not exist' do
-        expect { subject.chdir('/nowhere') }.to raise_error(Errno::ENOENT)
+        expect { described_class.chdir('/nowhere') }.to raise_error(Errno::ENOENT)
       end
 
       context 'when a block is given' do
         it 'changes current working directory for the block' do
-          subject.chdir '/test' do
-            expect(subject.pwd).to eq('/test')
+          described_class.chdir '/test' do
+            expect(described_class.pwd).to eq('/test')
           end
         end
 
         it 'gets back to previous directory once the block is finished' do
-          subject.chdir '/'
+          described_class.chdir '/'
           expect {
-            subject.chdir('/test') {}
-          }.to_not change { subject.pwd }
+            described_class.chdir('/test') {}
+          }.to_not change { described_class.pwd }
         end
       end
     end
@@ -61,27 +59,27 @@ module MemFs
 
       it "changes the process's idea of the file system root" do
 
-        subject.mkdir('/test/subdir')
-        subject.chroot('/test')
+        described_class.mkdir('/test/subdir')
+        described_class.chroot('/test')
 
         expect(File.exist?('/subdir')).to be true
       end
 
       it 'returns zero' do
-        expect(subject.chroot('/test')).to eq 0
+        expect(described_class.chroot('/test')).to eq 0
       end
 
       context 'when the given path is a file' do
         before { _fs.touch('/test/test-file') }
 
         it 'raises an exception' do
-          expect { subject.chroot('/test/test-file') }.to raise_error(Errno::ENOTDIR)
+          expect { described_class.chroot('/test/test-file') }.to raise_error(Errno::ENOTDIR)
         end
       end
 
       context "when the given path doesn't exist" do
         it 'raises an exception' do
-          expect { subject.chroot('/no-dir') }.to raise_error(Errno::ENOENT)
+          expect { described_class.chroot('/no-dir') }.to raise_error(Errno::ENOENT)
         end
       end
 
@@ -89,40 +87,42 @@ module MemFs
         before { allow(Process).to receive_messages(uid: 42) }
 
         it 'raises an exception' do
-          expect { subject.chroot('/no-dir') }.to raise_error(Errno::EPERM)
+          expect { described_class.chroot('/no-dir') }.to raise_error(Errno::EPERM)
         end
       end
     end
 
     describe '.delete' do
+      subject { described_class }
       it_behaves_like 'aliased method', :delete, :rmdir
     end
 
     describe '.entries' do
       it 'returns an array containing all of the filenames in the given directory' do
-        %w[/test/dir1 /test/dir2].each { |dir| subject.mkdir dir }
+        %w[/test/dir1 /test/dir2].each { |dir| described_class.mkdir dir }
         _fs.touch '/test/file1', '/test/file2'
-        expect(subject.entries('/test')).to eq(%w[. .. dir1 dir2 file1 file2])
+        expect(described_class.entries('/test')).to eq(%w[. .. dir1 dir2 file1 file2])
       end
     end
 
     describe '.exist?' do
+      subject { described_class }
       it_behaves_like 'aliased method', :exist?, :exists?
     end
 
     describe '.exists?' do
       it 'returns true if the given +path+ exists and is a directory' do
-        subject.mkdir('/test-dir')
-        expect(subject.exists?('/test-dir')).to be true
+        described_class.mkdir('/test-dir')
+        expect(described_class.exists?('/test-dir')).to be true
       end
 
       it 'returns false if the given +path+ does not exist' do
-        expect(subject.exists?('/test-dir')).to be false
+        expect(described_class.exists?('/test-dir')).to be false
       end
 
       it 'returns false if the given +path+ is not a directory' do
         _fs.touch('/test-file')
-        expect(subject.exists?('/test-file')).to be false
+        expect(described_class.exists?('/test-file')).to be false
       end
     end
 
@@ -134,26 +134,26 @@ module MemFs
       context 'when a block is given' do
         it 'calls the block once for each entry in the named directory' do
           expect { |blk|
-            subject.foreach('/test', &blk)
+            described_class.foreach('/test', &blk)
           }.to yield_control.exactly(4).times
         end
 
         it 'passes each entry as a parameter to the block' do
           expect { |blk|
-            subject.foreach('/test', &blk)
+            described_class.foreach('/test', &blk)
           }.to yield_successive_args('.', '..', 'test-file', 'test-file2')
         end
 
         context "and the directory doesn't exist" do
           it 'raises an exception' do
-            expect { subject.foreach('/no-dir') {} }.to raise_error
+            expect { described_class.foreach('/no-dir') {} }.to raise_error
           end
         end
 
         context 'and the given path is not a directory' do
           it 'raises an exception' do
             expect {
-              subject.foreach('/test/test-file') {}
+              described_class.foreach('/test/test-file') {}
             }.to raise_error
           end
         end
@@ -161,20 +161,20 @@ module MemFs
 
       context 'when no block is given' do
         it 'returns an enumerator' do
-          list = subject.foreach('/test-dir')
+          list = described_class.foreach('/test-dir')
           expect(list).to be_an(Enumerator)
         end
 
         context "and the directory doesn't exist" do
           it 'returns an enumerator' do
-            list = subject.foreach('/no-dir')
+            list = described_class.foreach('/no-dir')
             expect(list).to be_an(Enumerator)
           end
         end
 
         context 'and the given path is not a directory' do
           it 'returns an enumerator' do
-            list = subject.foreach('/test-dir/test-file')
+            list = described_class.foreach('/test-dir/test-file')
             expect(list).to be_an(Enumerator)
           end
         end
@@ -183,7 +183,7 @@ module MemFs
 
     describe '.getwd' do
       it 'returns the path to the current working directory' do
-        expect(subject.getwd).to eq(FileSystem.instance.getwd)
+        expect(described_class.getwd).to eq(FileSystem.instance.getwd)
       end
     end
 
@@ -201,7 +201,7 @@ module MemFs
 
       shared_examples 'returning matching filenames' do |pattern, filenames|
         it "with #{pattern}" do
-          expect(subject.glob(pattern)).to eq filenames
+          expect(described_class.glob(pattern)).to eq filenames
         end
       end
 
@@ -222,37 +222,37 @@ module MemFs
 
       context 'when a flag is given' do
         it 'uses it to compare filenames' do
-          expect(subject.glob('/TEST*', File::FNM_CASEFOLD)).to eq \
+          expect(described_class.glob('/TEST*', File::FNM_CASEFOLD)).to eq \
             %w[/test0 /test1 /test2]
         end
       end
 
       context 'when a block is given' do
         it 'calls the block with every matching filenames' do
-          expect { |blk| subject.glob('/test*', &blk) }.to \
+          expect { |blk| described_class.glob('/test*', &blk) }.to \
             yield_successive_args('/test0', '/test1', '/test2')
         end
 
         it 'returns nil' do
-          expect(subject.glob('/*') {}).to be nil
+          expect(described_class.glob('/*') {}).to be nil
         end
       end
 
       context 'when pattern is an array of patterns' do
         it 'returns the list of files matching any pattern' do
-          expect(subject.glob(['/*0', '/*1'])).to eq %w[/test0 /test1]
+          expect(described_class.glob(['/*0', '/*1'])).to eq %w[/test0 /test1]
         end
       end
     end
 
     describe '.home' do
       it 'returns the home directory of the current user' do
-        expect(subject.home).to eq ENV['HOME']
+        expect(described_class.home).to eq ENV['HOME']
       end
 
       context 'when a username is given' do
         it 'returns the home directory of the given user' do
-          home_dir = subject.home(ENV['USER'])
+          home_dir = described_class.home(ENV['USER'])
           expect(home_dir).to eq ENV['HOME']
         end
       end
@@ -260,13 +260,25 @@ module MemFs
 
     describe '.mkdir' do
       it 'creates a directory' do
-        subject.mkdir '/new-folder'
+        described_class.mkdir '/new-folder'
         expect(File.directory?('/new-folder')).to be true
       end
 
+      it 'sets directory permissions to default 0777' do
+        described_class.mkdir '/new-folder'
+        expect(File.stat('/new-folder').mode).to eq(0100777)
+      end
+
+      context 'when permissions are specified' do
+        it 'sets directory permissions to specified value' do
+          described_class.mkdir '/new-folder', 0644
+          expect(File.stat('/new-folder').mode).to eq(0100644)
+        end
+      end
+
       context 'when the directory already exist' do
         it 'raises an exception' do
-          expect { subject.mkdir('/') }.to raise_error(Errno::EEXIST)
+          expect { described_class.mkdir('/') }.to raise_error(Errno::EEXIST)
         end
       end
     end
@@ -274,29 +286,29 @@ module MemFs
     describe '.open' do
       context 'when no block is given' do
         it 'returns the opened directory' do
-          expect(subject.open('/test')).to be_a(Dir)
+          expect(described_class.open('/test')).to be_a(Dir)
         end
       end
 
       context 'when a block is given' do
         it 'calls the block with the opened directory as argument' do
-          expect { |blk| subject.open('/test', &blk) }.to yield_with_args(Dir)
+          expect { |blk| described_class.open('/test', &blk) }.to yield_with_args(Dir)
         end
 
         it 'returns nil' do
-          expect(subject.open('/test') {}).to be_nil
+          expect(described_class.open('/test') {}).to be_nil
         end
 
         it 'ensures the directory is closed' do
           dir = nil
-          subject.open('/test') { |d| dir = d }
+          described_class.open('/test') { |d| dir = d }
           expect { dir.close }.to raise_error(IOError)
         end
       end
 
       context "when the given directory doesn't exist" do
         it 'raises an exception' do
-          expect { subject.open('/no-dir') }.to raise_error
+          expect { described_class.open('/no-dir') }.to raise_error
         end
       end
 
@@ -304,7 +316,7 @@ module MemFs
         before { _fs.touch('/test/test-file') }
 
         it 'raises an exception' do
-          expect { subject.open('/test/test-file') }.to raise_error
+          expect { described_class.open('/test/test-file') }.to raise_error
         end
       end
     end
@@ -312,7 +324,7 @@ module MemFs
     describe '.new' do
       context "when the given directory doesn't exist" do
         it 'raises an exception' do
-          expect { subject.new('/no-dir') }.to raise_error
+          expect { described_class.new('/no-dir') }.to raise_error
         end
       end
 
@@ -320,44 +332,46 @@ module MemFs
         before { _fs.touch('/test/test-file') }
 
         it 'raises an exception' do
-          expect { subject.new('/test/test-file') }.to raise_error
+          expect { described_class.new('/test/test-file') }.to raise_error
         end
       end
     end
 
     describe '.pwd' do
+      subject { described_class }
       it_behaves_like 'aliased method', :pwd, :getwd
     end
 
     describe '.rmdir' do
       it 'deletes the named directory' do
-        subject.mkdir('/test-dir')
-        subject.rmdir('/test-dir')
-        expect(subject.exists?('/test-dir')).to be false
+        described_class.mkdir('/test-dir')
+        described_class.rmdir('/test-dir')
+        expect(described_class.exists?('/test-dir')).to be false
       end
 
       context 'when the directory is not empty' do
         it 'raises an exception' do
-          subject.mkdir('/test-dir')
-          subject.mkdir('/test-dir/test-sub-dir')
-          expect { subject.rmdir('/test-dir') }.to raise_error(Errno::ENOTEMPTY)
+          described_class.mkdir('/test-dir')
+          described_class.mkdir('/test-dir/test-sub-dir')
+          expect { described_class.rmdir('/test-dir') }.to raise_error(Errno::ENOTEMPTY)
         end
       end
     end
 
     describe '.tmpdir' do
       it 'returns /tmp' do
-        expect(subject.tmpdir).to eq '/tmp'
+        expect(described_class.tmpdir).to eq '/tmp'
       end
     end
 
     describe '.unlink' do
+      subject { described_class }
       it_behaves_like 'aliased method', :unlink, :rmdir
     end
 
     describe '#close' do
       it 'closes the directory' do
-        dir = subject.open('/test')
+        dir = described_class.open('/test')
         dir.close
         expect { dir.close }.to raise_error(IOError)
       end
@@ -367,58 +381,58 @@ module MemFs
       before { _fs.touch('/test/test-file', '/test/test-file2') }
 
       it 'calls the block once for each entry in this directory' do
-        expect { |blk| instance.each(&blk) }.to yield_control.exactly(4).times
+        expect { |blk| subject.each(&blk) }.to yield_control.exactly(4).times
       end
 
       it 'passes the filename of each entry as a parameter to the block' do
         expect { |blk|
-          instance.each(&blk)
+          subject.each(&blk)
         }.to yield_successive_args('.', '..', 'test-file', 'test-file2')
       end
 
       context 'when no block is given' do
         it 'returns an enumerator' do
-          expect(instance.each).to be_an(Enumerator)
+          expect(subject.each).to be_an(Enumerator)
         end
       end
     end
 
     describe '#path' do
       it "returns the path parameter passed to dir's constructor" do
-        expect(instance.path).to eq '/test'
+        expect(subject.path).to eq '/test'
       end
     end
 
     describe '#pos' do
       it 'returns the current position in dir' do
-        3.times { instance.read }
-        expect(instance.pos).to eq 3
+        3.times { subject.read }
+        expect(subject.pos).to eq 3
       end
     end
 
     describe '#pos=' do
-      before { 3.times { instance.read } }
+      before { 3.times { subject.read } }
 
       it 'seeks to a particular location in dir' do
-        instance.pos = 1
-        expect(instance.pos).to eq 1
+        subject.pos = 1
+        expect(subject.pos).to eq 1
       end
 
       it 'returns the given position' do
-        expect(instance.pos = 2).to eq 2
+        expect(subject.pos = 2).to eq 2
       end
 
       context 'when the location has not been seeked yet' do
         it "doesn't change the location" do
-          instance.pos = 42
-          expect(instance.pos).to eq 3
+          subject.pos = 42
+          expect(subject.pos).to eq 3
         end
       end
 
       context 'when the location is negative' do
         it "doesn't change the location" do
-          instance.pos = -1
-          expect(instance.pos).to eq 3
+          subject.pos = -1
+          expect(subject.pos).to eq 3
         end
       end
     end
@@ -430,73 +444,73 @@ module MemFs
       end
 
       it 'reads the next entry from dir and returns it' do
-        expect(instance.read).to eq '.'
+        expect(subject.read).to eq '.'
       end
 
       context 'when calling several times' do
         it 'returns the next entry each time' do
-          2.times { instance.read }
-          expect(instance.read).to eq 'a'
+          2.times { subject.read }
+          expect(subject.read).to eq 'a'
         end
       end
 
       context 'when there are no entries left' do
         it 'returns nil' do
-          4.times { instance.read }
-          expect(instance.read).to be_nil
+          4.times { subject.read }
+          expect(subject.read).to be_nil
         end
       end
     end
 
     describe '#rewind' do
       it 'repositions dir to the first entry' do
-        3.times { instance.read }
-        instance.rewind
-        expect(instance.read).to eq '.'
+        3.times { subject.read }
+        subject.rewind
+        expect(subject.read).to eq '.'
       end
 
       it 'returns the dir itself' do
-        expect(instance.rewind).to be instance
+        expect(subject.rewind).to be subject
       end
     end
 
     describe '#seek' do
-      before { 3.times { instance.read } }
+      before { 3.times { subject.read } }
 
       it 'seeks to a particular location in dir' do
-        instance.seek(1)
-        expect(instance.pos).to eq 1
+        subject.seek(1)
+        expect(subject.pos).to eq 1
       end
 
       it 'returns the dir itself' do
-        expect(instance.seek(2)).to be instance
+        expect(subject.seek(2)).to be subject
       end
 
       context 'when the location has not been seeked yet' do
         it "doesn't change the location" do
-          instance.seek(42)
-          expect(instance.pos).to eq 3
+          subject.seek(42)
+          expect(subject.pos).to eq 3
         end
       end
 
       context 'when the location is negative' do
         it "doesn't change the location" do
-          instance.seek(-1)
-          expect(instance.pos).to eq 3
+          subject.seek(-1)
+          expect(subject.pos).to eq 3
         end
       end
     end
 
     describe '#tell' do
       it 'returns the current position in dir' do
-        3.times { instance.read }
-        expect(instance.tell).to eq 3
+        3.times { subject.read }
+        expect(subject.tell).to eq 3
       end
     end
 
     describe '#to_path' do
       it "returns the path parameter passed to dir's constructor" do
-        expect(instance.to_path).to eq '/test'
+        expect(subject.to_path).to eq '/test'
       end
     end
   end