memfs 0.0.1

data/spec/memfs/dir_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+module MemFs
+  describe Dir do
+    subject { MemFs::Dir }
+
+    before :each do
+      subject.mkdir '/test'
+    end
+
+    describe '.chdir' do
+      it "changes the current working directory" do
+        subject.chdir '/test'
+        expect(subject.getwd).to eq('/test')
+      end
+
+      it "returns zero" do
+        expect(subject.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)
+      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')
+          end
+        end
+    
+        it "gets back to previous directory once the block is finished" do
+          subject.chdir '/'
+          previous_dir = subject.pwd
+          subject.chdir('/test') {}
+          expect(subject.pwd).to eq(previous_dir)
+        end
+      end
+    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 }
+        fs.touch '/test/file1', '/test/file2'
+        expect(subject.entries('/test')).to eq(%w[. .. dir1 dir2 file1 file2])
+      end
+    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
+      end
+
+      it "returns false if the given +path+ does not exist" do
+        expect(subject.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
+      end
+    end
+
+    describe '.getwd' do
+      it "returns the path to the current working directory" do
+        expect(subject.getwd).to eq(FileSystem.instance.getwd)
+      end
+    end
+
+    describe '.mkdir' do
+      it "creates a directory" do
+        subject.mkdir '/new-folder'
+        expect(File.directory?('/new-folder')).to be_true
+      end
+
+      context "when the directory already exist" do
+        it "raises an exception" do
+          expect { subject.mkdir('/') }.to raise_error(Errno::EEXIST)
+        end
+      end
+    end
+
+    describe ".pwd" do
+      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
+      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)
+        end
+      end
+    end
+  end
+end

data/spec/memfs/fake/directory_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+module MemFs
+  module Fake
+    describe Directory do
+      let(:directory) { Directory.new('/test') }
+
+      describe '.new' do
+        it "sets . in the entries list" do
+          expect(directory.entries).to include('.' => directory)
+        end
+
+        it "sets .. in the entries list" do
+          expect(directory.entries).to have_key('..')
+        end
+      end
+
+      describe '#add_entry' do
+        let(:entry) { Directory.new('new_entry') }
+
+        it "adds the entry to the entries list" do
+          directory.add_entry entry
+          expect(directory.entries).to include('new_entry' => entry)
+        end
+
+        it "sets the parent of the added entry" do
+          directory.add_entry entry
+          expect(entry.parent).to be(directory)
+        end
+      end
+
+      describe "empty?" do
+        it "returns true if the directory is empty" do
+          expect(directory).to be_empty
+        end
+
+        it "returns false if the directory is not empty" do
+          directory.add_entry Directory.new('test')
+          expect(directory).not_to be_empty
+        end
+      end
+
+      describe '#entry_names' do
+        it "returns the list of the names of the entries in the directory" do
+          3.times do |n|
+            directory.add_entry Directory.new("dir#{n}")
+          end
+
+          expect(directory.entry_names).to eq(%w[. .. dir0 dir1 dir2])
+        end
+      end
+
+      describe '#find' do
+        let(:sub_directory) { Directory.new('sub_dir') }
+        let(:file) { File.new('file') }
+
+        before :each do
+          sub_directory.add_entry file
+          directory.add_entry sub_directory
+        end
+
+        it "returns the named entry if it is one of the entries" do
+          expect(directory.find('sub_dir')).to be(sub_directory)
+        end
+
+        it "calls find on the next directory in the search chain" do
+          expect(directory.find('sub_dir/file')).to be(file)
+        end
+
+        it "should remove any leading / in the path" do
+          expect(directory.find('/sub_dir/file')).to be(file)
+        end
+      end
+
+      describe '#parent=' do
+        let(:parent) { Directory.new('parent') }
+
+        it "sets the .. entry in entries list" do
+          directory.parent = parent
+          expect(directory.entries).to include('..' => parent)
+        end
+
+        it "sets the parent directory" do
+          directory.parent = parent
+          expect(directory.parent).to be(parent)
+        end
+      end
+
+      describe "#path" do
+        let(:root) { Directory.new('/') }
+
+        it "returns the directory path" do
+          directory.parent = root
+          expect(directory.path).to eq('/test')
+        end
+
+        context "when the directory is /" do
+          it "returns /" do
+            expect(root.path).to eq('/')
+          end
+        end
+      end
+
+      describe "#remove_entry" do
+        let(:file) { File.new('file') }
+
+        it "removes an entry from the entries list" do
+          directory.add_entry file
+          directory.remove_entry file
+          expect(directory.entries).not_to have_value(file)
+        end
+      end
+    end
+  end
+end

data/spec/memfs/fake/entry_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+module MemFs
+  module Fake
+    describe Entry do
+      let(:entry) { Entry.new('test') }
+      let(:parent) { Directory.new('parent') }
+      let(:time) { Time.now - 5000 }
+
+      before(:each) do
+        parent.parent = Directory.new('/')
+        entry.parent = parent
+      end
+
+      shared_examples 'it has accessors for' do |attribute|
+        let(:expected) { value }
+
+        it attribute do
+          entry.send(:"#{attribute}=", value)
+          expect(entry.public_send(attribute)).to eq(expected)
+        end
+      end
+
+      it_behaves_like 'it has accessors for', :name do
+        let(:value) { 'test' }
+      end
+
+      it_behaves_like 'it has accessors for', :atime do
+        let(:value) { time }
+      end
+
+      it_behaves_like 'it has accessors for', :mtime do
+        let(:value) { time }
+      end
+
+      it_behaves_like 'it has accessors for', :uid do
+        let(:value) { 42 }
+      end
+
+      it_behaves_like 'it has accessors for', :gid do
+        let(:value) { 42 }
+      end
+
+      it_behaves_like 'it has accessors for', :mode do
+        let(:value) { 0777 }
+        let(:expected) { 0100777 }
+      end
+
+      it_behaves_like 'it has accessors for', :parent do
+        let(:value) { parent }
+      end
+
+      describe ".delete" do
+        it "removes the entry from its parent" do
+          entry.delete
+          expect(parent.entries).not_to have_value(entry)
+        end
+      end
+
+      describe '.dereferenced' do
+        it "returns the entry itself" do
+          expect(entry.dereferenced).to be(entry)
+        end
+      end
+
+      describe '.find' do
+        it "raises an error" do
+          expect { entry.find('test') }.to raise_error(Errno::ENOTDIR)
+        end
+      end
+
+      describe ".new" do
+        it "sets its default uid to the current user's uid" do
+          expect(entry.uid).to eq(Etc.getpwuid.uid)
+        end
+
+        it "sets its default gid to the current user's gid" do
+          expect(entry.gid).to eq(Etc.getpwuid.gid)
+        end
+
+        it "extract its name from the path passed as argument" do
+          expect(entry.name).to eq('test')
+        end
+
+        it "sets an empty string as name if none is given" do
+          expect(Entry.new.name).to be_empty
+        end
+
+        it "sets the access time" do
+          expect(Entry.new.atime).to be_a(Time)
+        end
+
+        it "sets the modification time" do
+          expect(entry.mtime).to be_a(Time)
+        end
+
+        it "sets atime and mtime to the same value" do
+          expect(entry.atime).to eq(entry.mtime)
+        end
+      end
+
+      describe ".path" do
+        it "returns the complete path of the entry" do
+          expect(entry.path).to eq('/parent/test')
+        end
+      end
+
+      describe "#dev" do
+        it "returns an integer representing the device on which the entry resides" do
+          expect(entry.dev).to be_a(Fixnum)
+        end
+      end
+
+      describe "#ino" do
+        it "Returns the inode number for the entry" do
+          expect(entry.ino).to be_a(Fixnum)
+        end
+      end
+
+      describe "#touch" do
+        let(:time) { Time.now - 5000 }
+
+        before :each do
+          entry.atime = time
+          entry.mtime = time
+        end
+
+        it "sets the access time to now" do
+          entry.touch
+          expect(entry.atime).not_to eq(time)
+        end
+
+        it "sets the modification time to now" do
+          entry.touch
+          expect(entry.mtime).not_to eq(time)
+        end
+      end
+    end
+  end
+end

data/spec/memfs/fake/file/content_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+module MemFs
+  module Fake
+
+    describe File::Content do
+      subject { File::Content.new }
+
+      describe "#<<" do
+        it "writes the given string to the contained string" do
+          subject << 'test'
+          expect(subject.to_s).to eq('test')
+        end
+      end
+
+      describe "#initialize" do
+        context "when no argument is given" do
+          it "initialize the contained string to an empty one" do
+            expect(subject.to_s).to eq('')
+          end
+        end
+
+        context "when an argument is given" do
+          subject { File::Content.new(base_value) }
+
+          context "when the argument is a string" do
+            let(:base_value) { 'test' }
+
+            it "initialize the contained string with the given one" do
+              expect(subject.to_s).to eq('test')
+            end
+
+            it "duplicates the original string to prevent modifications on it" do
+              expect(subject.to_s).not_to be(base_value)
+            end
+          end
+
+          context "when the argument is not a string" do
+            let(:base_value) { 42 }
+
+            it "converts it to a string" do
+              expect(subject.to_s).to eq('42')
+            end
+          end
+        end
+      end
+
+      describe "#puts" do
+        it "appends the given string to the contained string" do
+          subject.puts 'test'
+          expect(subject.to_s).to eq("test\n")
+        end
+
+        it "appends all given strings to the contained string" do
+          subject.puts 'this', 'is', 'a', 'test'
+          expect(subject.to_s).to eq("this\nis\na\ntest\n")
+        end
+
+        context "when a line break is present at the end of the given string" do
+          it "doesn't add any line break" do
+            subject.puts "test\n"
+            expect(subject.to_s).not_to eq("test\n\n")
+          end
+        end
+      end
+
+      describe "#to_s" do
+        context "when the content is empty" do
+          it "returns an empty string" do
+            expect(subject.to_s).to eq('')
+          end
+        end
+
+        context "when the content is not empty" do
+          it "returns the content's string" do
+            subject << 'test'
+            expect(subject.to_s).to eq('test')
+          end
+        end
+      end
+
+      describe "#write" do
+        it "writes the given string in content" do
+          subject.write 'test'
+          expect(subject.to_s).to eq('test')
+        end
+
+        it "returns the number of bytes written" do
+          expect(subject.write('test')).to eq(4)
+        end
+
+        context "when the argument is not a string" do
+          it "converts it to a string" do
+            subject.write 42
+            expect(subject.to_s).to eq('42')
+          end
+        end
+
+        context "when the argument is a non-ascii string" do
+          it "returns the correct number of bytes written" do
+            expect(subject.write('é')).to eq(1)
+          end
+        end
+      end
+
+      context "when initialized with a string argument" do
+        subject { File::Content.new('test') }
+
+        describe "#read" do
+          it "reads +length+ bytes from the contained string" do
+            expect(subject.read(2)).to eq('te')
+          end
+
+          context "when there is nothing else to read" do
+            it "returns nil" do
+              subject.read 4
+              expect(subject.read(1)).to be_nil
+            end
+          end
+
+          context "when the optional +buffer+ argument is provided" do
+            it "inserts the output in the buffer" do
+              string = String.new
+              subject.read(2, string)
+              expect(string).to eq('te')
+            end
+          end
+        end
+
+        describe "#pos" do
+          context "when the string has not been read" do
+            it "returns 0" do
+              expect(subject.pos).to eq(0)
+            end
+          end
+
+          context "when the string has been read" do
+            it "returns the current offset" do
+              subject.read 2
+              expect(subject.pos).to eq(2)
+            end
+          end
+        end
+
+        describe "#close" do
+          it "responds to close" do
+            expect(subject).to respond_to(:close)
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/memfs/fake/file_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module MemFs
+  module Fake
+    describe File do
+      let(:file) { fs.find!('/test-file') }
+
+      before do
+        fs.touch('/test-file')
+      end
+
+      it "stores the modification made on its content" do
+        file.content << 'test'
+        expect(fs.find!('/test-file').content.to_s).to eq('test')
+      end
+
+      describe "#close" do
+        it "sets the file as closed?" do
+          file.close
+          expect(file).to be_closed
+        end
+      end
+
+      describe "#content" do
+        it "returns the file content" do
+          expect(file.content).not_to be_nil
+        end
+
+        context "when the file is empty" do
+          it "returns an empty string container" do
+            expect(file.content.to_s).to be_empty
+          end
+        end
+      end
+    end
+  end
+end

data/spec/memfs/fake/symlink_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module MemFs
+  module Fake
+    describe Symlink do
+      describe '#content' do
+        it "returns the target's content" do
+          MemFs::File.open('/test-file', 'w') { |f| f.puts "test" }
+          s = Symlink.new('/test-link', '/test-file')
+          expect(s.content).to be(s.dereferenced.content)
+        end
+      end
+
+      describe '#dereferenced' do
+        it "returns the target if it's not a symlink" do
+          fs.touch '/test-file'
+          target = fs.find!('/test-file')
+
+          s = Symlink.new('/test-link', '/test-file')
+
+          expect(s.dereferenced).to eq(target)
+        end
+
+        it "returns the last target of the chain" do
+          fs.touch '/test-file'
+          target = fs.find!('/test-file')
+
+          fs.symlink '/test-file', '/test-link'
+          s = Symlink.new('/test-link2', '/test-link')
+
+          expect(s.dereferenced).to eq(target)
+        end
+      end
+
+      describe '#target' do
+        it "returns the target of the symlink" do
+          s = Symlink.new('/test-link', '/test-file')
+          expect(s.target).to eq('/test-file')
+        end
+      end
+    end
+  end
+end