fakefs 0.2.0 → 0.2.1

data/.gitignore

@@ -0,0 +1 @@
+*.sw?

data/CONTRIBUTORS

@@ -0,0 +1,12 @@
+* Chris Wanstrath
+* Jeff Hodges
+* Scott Taylor
+* Pat Nakajima
+* Myles Eftos
+* Matt Freels
+* Nick Quaranto
+* Tymon Tobolski
+* msassak
+* Rob Sanheim
+* Jon Yurek
+* David Reese

data/README.markdown

@@ -48,6 +48,13 @@ Don't Fake the FS Immediately
     end
 
 
+RSpec
+-----------------------------
+The above approach works with RSpec as well. In addition to this you may use the
+'use_fakefs' macro to turn FakeFS on and off in a given example group.  See
+lib/spec_helpers for more details on it's usage.
+
+
 How is this different than MockFS?
 ----------------------------------
 
@@ -56,6 +63,14 @@ test-time dependency: your actual library does not need to use or know about
 FakeFS.
 
 
+Caveats
+-------
+
+FakeFS internally uses the `Pathname` and `FileUtils` constants. If you use
+these in your app, be certain you're properly requiring them and not counting
+on FakeFS' own require.
+
+
 Speed?
 ------
 <http://gist.github.com/156091>
@@ -73,26 +88,11 @@ Installation
     $ rip install git://github.com/defunkt/fakefs.git
 
 
-Contributors
-------------
-
-* Chris Wanstrath
-* David Reese
-* Jeff Hodges
-* Jon Yurek
-* Matt Freels
-* Myles Eftos
-* Pat Nakajima
-* Rob Sanheim
-* Scott Taylor
-* Tymon Tobolski
-* msassak
-
-
 Meta
 ----
 
 * Code: `git clone git://github.com/defunkt/fakefs.git`
+* Home: <http://github.com/defunkt/fakefs>
 * Docs: <http://defunkt.github.com/fakefs>
 * Bugs: <http://github.com/defunkt/fakefs/issues>
 * List: <http://groups.google.com/group/fakefs>

data/Rakefile

@@ -31,3 +31,17 @@ begin
 rescue LoadError
   puts "sdoc support not enabled. Please gem install sdoc-helpers."
 end
+
+desc "Build a gem"
+task :gem => [ :gemspec, :build ]
+
+desc "Push a new version to Gemcutter"
+task :publish => [ :gemspec, :build ] do
+  abort("Tests failed!") unless system("rake test")
+  system "git tag v#{FakeFS::Version}"
+  system "git push origin v#{FakeFS::Version}"
+  system "git push origin master"
+  system "gem push pkg/fakefs-#{FakeFS::Version}.gem"
+  system "git clean -fd"
+  exec "rake pages"
+end

data/lib/fakefs/base.rb

@@ -31,8 +31,8 @@ end
 def FakeFS
   return ::FakeFS unless block_given?
   ::FakeFS.activate!
-  result = yield
-  ::FakeFS.deactivate!
-  result
+  yield
+ensure
+::FakeFS.deactivate!
 end
 

data/lib/fakefs/dir.rb

@@ -71,7 +71,7 @@ module FakeFS
 
     def self.entries(dirname)
       raise SystemCallError, dirname unless FileSystem.find(dirname)
-      Dir.new(dirname).map { |file| file }
+      Dir.new(dirname).map { |file| File.basename(file) }
     end
 
     def self.foreach(dirname, &block)

data/lib/fakefs/fake/file.rb

@@ -1,6 +1,6 @@
 module FakeFS
   class FakeFile
-    attr_accessor :name, :parent
+    attr_accessor :name, :parent, :content, :mtime
 
     class Inode
       def initialize(file_owner)
@@ -19,12 +19,19 @@ module FakeFS
       def unlink(file)
         links.delete(file)
       end
+
+      def clone
+        clone = super
+        clone.content = content.dup
+        clone
+      end
     end
 
     def initialize(name = nil, parent = nil)
       @name   = name
       @parent = parent
       @inode  = Inode.new(self)
+      @mtime  = Time.now
     end
 
     attr_accessor :inode

data/lib/fakefs/file.rb

@@ -13,19 +13,18 @@ module FakeFS
 
     FILE_CREATION_MODES = MODES - [READ_ONLY, READ_WRITE]
 
-    READ_ONLY_MODES = [
-      READ_ONLY
-    ]
-
-    WRITE_ONLY_MODES = [
-      WRITE_ONLY,
-      APPEND_WRITE_ONLY
-    ]
-
-    TRUNCATION_MODES = [
-      WRITE_ONLY,
-      READ_WRITE_TRUNCATE
-    ]
+    MODE_BITMASK = RealFile::RDONLY   |
+                   RealFile::WRONLY   |
+                   RealFile::RDWR     |
+                   RealFile::APPEND   |
+                   RealFile::CREAT    |
+                   RealFile::EXCL     |
+                   RealFile::NONBLOCK |
+                   RealFile::TRUNC    |
+                   RealFile::NOCTTY   |
+                   RealFile::SYNC
+
+    FILE_CREATION_BITMASK = RealFile::CREAT
 
     def self.extname(path)
       RealFile.extname(path)
@@ -41,12 +40,32 @@ module FakeFS
 
     class << self
       alias_method :exists?, :exist?
+
+      # Assuming that everyone can read and write files
+      alias_method :readable?, :exist?
+      alias_method :writable?, :exist?
+    end
+
+    def self.mtime(path)
+      if exists?(path)
+        FileSystem.find(path).mtime
+      else
+        raise Errno::ENOENT
+      end
     end
 
     def self.size(path)
       read(path).length
     end
 
+    def self.size?(path)
+      if exists?(path) && !size(path).zero?
+        true
+      else
+        nil
+      end
+    end
+
     def self.const_missing(name)
       RealFile.const_get(name)
     end
@@ -114,7 +133,7 @@ module FakeFS
     def self.readlines(path)
       read(path).split("\n")
     end
-    
+
     def self.link(source, dest)
       if directory?(source)
         raise Errno::EPERM, "Operation not permitted - #{source} or #{dest}"
@@ -123,11 +142,11 @@ module FakeFS
       if !exists?(source)
         raise Errno::ENOENT, "No such file or directory - #{source} or #{dest}"
       end
-      
+
       if exists?(dest)
         raise Errno::EEXIST, "File exists - #{source} or #{dest}"
       end
-      
+
       source = FileSystem.find(source)
       dest = FileSystem.add(dest, source.entry.clone)
       source.link(dest)
@@ -191,75 +210,67 @@ module FakeFS
       @file = FileSystem.find(path)
       @open = true
 
-      check_valid_mode
+      check_modes!
+
       file_creation_mode? ? create_missing_file : check_file_existence!
-      truncate_file if truncation_mode?
+
+      @stream = StringIO.new(@file.content, mode)
     end
 
     def close
       @open = false
     end
 
-    def read
-      raise IOError, 'closed stream' unless @open
-      raise IOError, 'not opened for reading' if write_only?
+    def read(chunk = nil)
+      @stream.read(chunk)
+    end
 
-      @file.content
+    def rewind
+      @stream.rewind
     end
 
     def exists?
-      @file
+      true
     end
 
     def puts(*content)
-      content.flatten.each do |obj|
-        write(obj.to_s + "\n")
-      end
+      @stream.puts(*content)
     end
 
     def write(content)
-      raise IOError, 'closed stream' unless @open
-      raise IOError, 'not open for writing' if read_only?
-
-      @file.content += content
+      @stream.write(content)
     end
     alias_method :print, :write
     alias_method :<<, :write
 
     def flush; self; end
 
+    def seek(amount, whence = SEEK_SET)
+      @stream.seek(amount, whence)
+    end
+
   private
 
+    def check_modes!
+      StringIO.new("", @mode)
+    end
+
     def check_file_existence!
       unless @file
         raise Errno::ENOENT, "No such file or directory - #{@file}"
       end
     end
 
-    def check_valid_mode
-      if !mode_in?(MODES)
-        raise ArgumentError, "illegal access mode #{@mode}"
-      end
-    end
-
-    def read_only?
-      mode_in? READ_ONLY_MODES
-    end
-
     def file_creation_mode?
-      mode_in? FILE_CREATION_MODES
-    end
-
-    def write_only?
-      mode_in? WRITE_ONLY_MODES
+      mode_in?(FILE_CREATION_MODES) || mode_in_bitmask?(FILE_CREATION_BITMASK)
     end
 
-    def truncation_mode?
-      mode_in? TRUNCATION_MODES
+    def mode_in?(list)
+      list.any? { |element| @mode.include?(element) } if @mode.respond_to?(:include?)
     end
 
-    def mode_in?(list)
-      list.include?(@mode)
+    def mode_in_bitmask?(mask)
+      (@mode & mask) != 0 if @mode.is_a?(Integer)
     end
 
     def create_missing_file
@@ -267,9 +278,5 @@ module FakeFS
         @file = FileSystem.add(path, FakeFile.new)
       end
     end
-
-    def truncate_file
-      @file.content = ""
-    end
   end
 end

data/lib/fakefs/file_system.rb

@@ -106,7 +106,20 @@ module FakeFS
       return [] unless dir.respond_to? :[]
 
       pattern , *parts = parts
-      matches = dir.reject {|k,v| /\A#{pattern.gsub('?','.').gsub('*', '.*')}\Z/ !~ k }.values
+      matches = case pattern
+      when '**'
+        case parts
+        when ['*'], []
+          parts = [] # end recursion
+          directories_under(dir).map do |d|
+            d.values.select{|f| f.is_a? FakeFile }
+          end.flatten.uniq
+        else
+          directories_under(dir)
+        end
+      else
+        dir.reject {|k,v| /\A#{pattern.gsub('?','.').gsub('*', '.*')}\Z/ !~ k }.values
+      end
 
       if parts.empty? # we're done recursing
         matches
@@ -114,5 +127,10 @@ module FakeFS
         matches.map{|entry| find_recurser(entry, parts) }
       end
     end
+
+    def directories_under(dir)
+      children = dir.values.select{|f| f.is_a? FakeDir}
+      ([dir] + children + children.map{|c| directories_under(c)}).flatten.uniq
+    end
   end
 end

data/lib/fakefs/fileutils.rb

@@ -25,11 +25,18 @@ module FakeFS
 
     alias_method :rm_rf, :rm
     alias_method :rm_r, :rm
+    alias_method :rm_f, :rm
 
-    def ln_s(target, path)
-      raise Errno::EEXIST, path if FileSystem.find(path)
+    def ln_s(target, path, options = {})
+      options = { :force => false }.merge(options)
+      (FileSystem.find(path) and !options[:force]) ? raise(Errno::EEXIST, path) : FileSystem.delete(path)
       FileSystem.add(path, FakeSymlink.new(target))
     end
+    def ln_sf(target, path)
+      ln_s(target, path, { :force => true })
+    end
+
+    
 
     def cp(src, dest)
       dst_file = FileSystem.find(dest)

data/lib/fakefs/spec_helpers.rb

@@ -0,0 +1,46 @@
+# FakeFS::SpecHelpers provides a simple macro for RSpec example groups to turn FakeFS on and off.
+# To use it simply require 'fakefs/spec_helpers', then include FakeFS::SpecHelpers into any
+# example groups that you wish to use FakeFS in. For example:
+#
+#   require 'fakefs/spec_helpers'
+#
+#   describe "Some specs that deal with files" do
+#     include FakeFS::SpecHelpers
+#     ...
+#   end
+#
+# Alternatively, you can include FakeFS::SpecHelpers in all your example groups using RSpec's
+# configuration block in your spec helper:
+#
+#   require 'fakefs/spec_helpers'
+#
+#   Spec::Runner.configure do |config|
+#     config.include FakeFS::SpecHelpers
+#   end
+#
+# If you do the above then use_fakefs will be available in all of your example groups.
+#
+require 'fakefs/safe'
+
+module FakeFS
+  module SpecHelpers
+    def self.extended(example_group)
+      example_group.use_fakefs(example_group)
+    end
+
+    def self.included(example_group)
+      example_group.extend self
+    end
+
+    def use_fakefs(describe_block)
+      describe_block.before :each do
+        FakeFS.activate!
+      end
+
+      describe_block.after :each do
+        FakeFS.deactivate!
+        FakeFS::FileSystem.clear
+      end
+    end
+  end
+end

data/lib/fakefs/version.rb

@@ -1,6 +1,6 @@
 module FakeFS
   module Version
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
 
     def self.to_s
       VERSION

data/spec/fakefs/spec_helpers_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module FakeFS
+  describe SpecHelpers do
+    before do
+      @rspec_example_group = Class.new do
+        def self.before(sym = :each)
+          yield if block_given?
+        end
+
+        def self.after(sym = :each)
+          yield if block_given?
+        end
+      end
+    end
+
+    describe "when extending" do
+      context "before each" do
+        it "should call it" do
+          @rspec_example_group.should_receive(:before).with(:each)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+
+        it "should call FakeFS.activate!" do
+          FakeFS.should_receive(:activate!)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+      end
+
+      context "after each" do
+        it "should call it" do
+          @rspec_example_group.should_receive(:after).with(:each)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+
+        it "should deactivate fakefs" do
+          FakeFS.should_receive(:deactivate!)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+
+        it "should clear the fakefs filesystem for the next run" do
+          FakeFS::FileSystem.should_receive(:clear)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+      end
+    end
+
+    describe "when including" do
+      it "should call before :each" do
+        @rspec_example_group.should_receive(:before)
+        @rspec_example_group.class_eval do
+          include FakeFS::SpecHelpers
+        end
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'fakefs/spec_helpers'

data/test/fake/symlink_test.rb

@@ -4,8 +4,9 @@ require 'test/unit'
 
 class FakeSymlinkTest < Test::Unit::TestCase
   include FakeFS
-  
+
   def test_symlink_has_method_missing_as_private
-    assert FakeSymlink.private_instance_methods.include?("method_missing")
+    methods = FakeSymlink.private_instance_methods.map { |m| m.to_s }
+    assert methods.include?("method_missing")
   end
-end
+end

data/test/fakefs_test.rb

@@ -74,6 +74,20 @@ class FakeFSTest < Test::Unit::TestCase
       FileUtils.ln_s(target, '/path/to/link')
     end
   end
+  
+  def test_can_force_creation_of_symlinks
+    FileUtils.mkdir_p(target = "/path/to/first/target")
+    FileUtils.ln_s(target, "/path/to/link")
+    assert_kind_of FakeSymlink, FileSystem.fs['path']['to']['link']
+    FileUtils.ln_s(target, '/path/to/link', :force => true)
+  end
+  
+  def test_create_symlink_using_ln_sf
+    FileUtils.mkdir_p(target = "/path/to/first/target")
+    FileUtils.ln_s(target, "/path/to/link")
+    assert_kind_of FakeSymlink, FileSystem.fs['path']['to']['link']
+    FileUtils.ln_sf(target, '/path/to/link')
+  end
 
   def test_can_follow_symlinks
     FileUtils.mkdir_p(target = "/path/to/target")
@@ -94,6 +108,19 @@ class FakeFSTest < Test::Unit::TestCase
     end
 
     assert File.exists?(path)
+    assert File.readable?(path)
+    assert File.writable?(path)
+  end
+
+  def test_can_create_files_with_bitmasks
+    path = '/path/to/file.txt'
+    File.open(path, File::RDWR | File::CREAT) do |f|
+      f.write "Yatta!"
+    end
+
+    assert File.exists?(path)
+    assert File.readable?(path)
+    assert File.writable?(path)
   end
 
   def test_file_opens_in_read_only_mode
@@ -106,6 +133,16 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
+  def test_file_opens_in_read_only_mode_with_bitmasks
+    File.open("foo", "w") { |f| f << "foo" }
+
+    f = File.open("foo", File::RDONLY)
+
+    assert_raises(IOError) do
+      f << "bar"
+    end
+  end
+
   def test_file_opens_in_invalid_mode
     FileUtils.touch("foo")
 
@@ -131,6 +168,17 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.exists?("foo")
   end
 
+  def test_creates_files_in_write_only_mode_with_bitmasks
+    File.open("foo", File::WRONLY | File::CREAT)
+    assert File.exists?("foo")
+  end
+
+  def test_raises_in_write_only_mode_without_create_bitmask
+    assert_raises(Errno::ENOENT) do
+      File.open("foo", File::WRONLY)
+    end
+  end
+
   def test_creates_files_in_read_write_truncate_mode
     File.open("foo", "w+")
     assert File.exists?("foo")
@@ -199,6 +247,30 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 'Yada Yada', File.read(path)
   end
 
+  def test_raises_error_when_opening_with_binary_mode_only
+    assert_raise ArgumentError do
+      File.open("/foo", "b")
+    end
+  end
+
+  def test_can_open_file_in_binary_mode
+    File.open("/foo", "wb") { |x| x << "a" }
+    assert_equal "a", File.read("/foo")
+  end
+
+  def test_can_chunk_io_when_reading
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f << 'Yada Yada'
+    end
+    file = File.new(path, 'r')
+    assert_equal 'Yada', file.read(4)
+    assert_equal ' Yada', file.read(5)
+    assert_equal '', file.read
+    file.rewind
+    assert_equal 'Yada Yada', file.read
+  end
+
   def test_can_get_size_of_files
     path = '/path/to/file.txt'
     File.open(path, 'w') do |f|
@@ -207,6 +279,37 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 9, File.size(path)
   end
 
+  def test_can_check_if_file_has_size?
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f << 'Yada Yada'
+    end
+    assert File.size?(path)
+    assert_nil File.size?("/path/to/other.txt")
+  end
+
+  def test_can_check_size?_of_empty_file
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f << ''
+    end
+    assert_nil File.size?("/path/to/file.txt")
+  end
+
+  def test_raises_error_on_mtime_if_file_does_not_exist
+    assert_raise Errno::ENOENT do
+      File.mtime('/path/to/file.txt')
+    end
+  end
+
+  def test_can_return_mtime_on_existing_file
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f << ''
+    end
+    assert File.mtime('/path/to/file.txt').is_a?(Time)
+  end
+
   def test_can_read_with_File_readlines
     path = '/path/to/file.txt'
     File.open(path, 'w') do |f|
@@ -327,6 +430,21 @@ class FakeFSTest < Test::Unit::TestCase
     #assert_equal ['/'], Dir['/']
   end
 
+  def test_dir_glob_handles_recursive_globs
+    File.open('/one/two/three/four.rb', 'w')
+    File.open('/one/five.rb', 'w')
+    assert_equal ['/one/five.rb', '/one/two/three/four.rb'], Dir['/one/**/*.rb']
+    assert_equal ['/one/two'], Dir['/one/**/two']
+    assert_equal ['/one/two/three'], Dir['/one/**/three']
+  end
+
+  def test_dir_recursive_glob_ending_in_wildcards_only_returns_files
+    File.open('/one/two/three/four.rb', 'w')
+    File.open('/one/five.rb', 'w')
+    assert_equal ['/one/five.rb', '/one/two/three/four.rb'], Dir['/one/**/*']
+    assert_equal ['/one/five.rb', '/one/two/three/four.rb'], Dir['/one/**']
+  end
+
   def test_chdir_changes_directories_like_a_boss
     # I know memes!
     FileUtils.mkdir_p '/path'
@@ -851,6 +969,20 @@ class FakeFSTest < Test::Unit::TestCase
     test.each { |t| assert yielded.include?(t) }
   end
 
+  def test_directory_entries_works_with_trailing_slash
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+
+    FileUtils.mkdir_p('/this/path/should/be/here')
+
+    test.each do |f|
+      FileUtils.touch("/this/path/should/be/here/#{f}")
+    end
+
+    yielded = Dir.entries('/this/path/should/be/here/')
+    assert yielded.size == test.size
+    test.each { |t| assert yielded.include?(t) }
+  end
+
   def test_directory_foreach
     test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
 
@@ -1060,6 +1192,59 @@ class FakeFSTest < Test::Unit::TestCase
     assert !File.exists?("/foo")
   end
 
+  def test_file_seek_returns_0
+    File.open("/foo", "w") do |f|
+      f << "one\ntwo\nthree"
+    end
+
+    file = File.open("/foo", "r")
+
+    assert_equal 0, file.seek(1)
+  end
+
+  def test_file_seek_seeks_to_location
+    File.open("/foo", "w") do |f|
+      f << "123"
+    end
+
+    file = File.open("/foo", "r")
+    file.seek(1)
+    assert_equal "23", file.read
+  end
+
+  def test_file_seek_seeks_to_correct_location
+    File.open("/foo", "w") do |f|
+      f << "123"
+    end
+
+    file = File.open("/foo", "r")
+    file.seek(2)
+    assert_equal "3", file.read
+  end
+
+  def test_file_seek_can_take_negative_offset
+    File.open("/foo", "w") do |f|
+      f << "123456789"
+    end
+
+    file = File.open("/foo", "r")
+
+    file.seek(-1, IO::SEEK_END)
+    assert_equal "9", file.read
+
+    file.seek(-2, IO::SEEK_END)
+    assert_equal "89", file.read
+
+    file.seek(-3, IO::SEEK_END)
+    assert_equal "789", file.read
+  end
+
+  def test_should_have_constants_inherited_from_descending_from_io
+    assert_equal IO::SEEK_CUR, File::SEEK_CUR
+    assert_equal IO::SEEK_END, File::SEEK_END
+    assert_equal IO::SEEK_SET, File::SEEK_SET
+  end
+
   def here(fname)
     RealFile.expand_path(RealFile.dirname(__FILE__)+'/'+fname)
   end

data/test/safe_test.rb

@@ -26,4 +26,17 @@ class FakeFSSafeTest < Test::Unit::TestCase
 
     assert_equal result, "Yatta!"
   end
+  
+  def test_FakeFS_method_deactivates_FakeFS_when_block_raises_exception
+    begin
+      FakeFS do
+        raise 'boom!'
+      end
+    rescue
+    end
+    
+    assert_equal RealFile, File, "File is #{File} (should be #{RealFile})"
+    assert_equal RealFileUtils, FileUtils, "FileUtils is #{FileUtils} (should be #{RealFileUtils})"    
+    assert_equal RealDir, Dir, "Dir is #{Dir} (should be #{RealDir})"
+  end  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fakefs
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Chris Wanstrath
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-06 00:00:00 -07:00
+date: 2009-10-30 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -23,6 +23,8 @@ extra_rdoc_files:
 - LICENSE
 - README.markdown
 files: 
+- .gitignore
+- CONTRIBUTORS
 - LICENSE
 - README.markdown
 - Rakefile
@@ -36,7 +38,11 @@ files:
 - lib/fakefs/file_system.rb
 - lib/fakefs/fileutils.rb
 - lib/fakefs/safe.rb
+- lib/fakefs/spec_helpers.rb
 - lib/fakefs/version.rb
+- spec/fakefs/spec_helpers_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
 - test/fake/file_test.rb
 - test/fake/symlink_test.rb
 - test/fakefs_test.rb
@@ -72,6 +78,8 @@ signing_key:
 specification_version: 3
 summary: A fake filesystem. Use it in your tests.
 test_files: 
+- spec/fakefs/spec_helpers_spec.rb
+- spec/spec_helper.rb
 - test/fake/file_test.rb
 - test/fake/symlink_test.rb
 - test/fakefs_test.rb