fun_with_files 0.0.15 → 0.0.18

data/test/test_fwf_assertions.rb

@@ -0,0 +1,62 @@
+module FunWith
+  module Testing
+    class TestFwfAssertions < FunWith::Testing::AssertionsTestCase
+      context "testing assertions" do
+        setup do
+          extended_test_case  # sets @case, which is used to access to assertions
+          @case_class.install_fun_with_files_assertions
+        end
+        
+        context "testing :assert_fwf_filepath()" do
+          should "pass all tests" do
+            testing_method :assert_fwf_filepath do
+              nope __FILE__
+              yep  __FILE__.fwf_filepath
+              
+              nope nil
+              nope :five
+              nope 5
+              nope [5]
+              nope "five"
+            end
+          end
+        end
+          
+        context "testing :assert_file()" do
+          should "pass all tests" do
+            testing_method :assert_file do
+              yep  __FILE__.fwf_filepath
+              
+              nope __FILE__
+              nope nil
+              nope :five
+              nope 5
+              nope [5]
+              nope "five"
+            end
+          end
+        end
+        
+        context "testing :assert_directory()" do
+          should "pass all tests" do
+            testing_method :assert_directory do
+              nope __FILE__
+              nope __FILE__.fwf_filepath
+              
+              yep  __FILE__.fwf_filepath.dirname
+              yep  __FILE__.fwf_filepath.up
+              yep  FunWith::Files.root
+              
+              nope nil
+              nope :five
+              nope 5
+              nope [5]
+              nope "five"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/test/test_moving_files.rb

@@ -0,0 +1,111 @@
+require 'helper'
+
+class TestMovingFiles < FunWith::Files::TestCase
+  context "inside a tmpdir" do
+    setup do
+      @src_dir = FilePath.tmpdir
+      @dst_dir = FilePath.tmpdir
+      
+      assert_directory @src_dir
+      assert_directory @dst_dir
+      
+      assert_empty_directory @src_dir
+      assert_empty_directory @dst_dir
+    end
+    
+    teardown do
+      @src_dir.rm
+      @dst_dir.rm
+      assert_not_directory @src_dir
+      assert_not_directory @dst_dir
+    end
+    
+    context "with a source file" do
+      setup do
+        @src_file = @src_dir / "file.txt"
+        @src_file.write( "Hello world" )
+        
+        assert_file_not_empty( @src_file )
+      end
+      
+      
+      should "successfully move a file into a directory" do
+        dest = @dst_dir / "file.txt"
+        
+        assert_no_file dest
+        
+        @src_file.move @dst_dir
+        
+        assert_file dest 
+      end
+      
+      
+      
+      # Seems dangerous to not have a concrete idea of what should happen when a move
+      # remove / create request takes place.  Ideas:
+      # be able to mark a destination as a directory, so that it knows the file move 
+      # is saying to
+      #
+      #  a directory should be created
+      #  a directory must exist for the move to occur
+      #  nothing exists at the destination, so the file is given the name of <thing_what_didnt_exist>
+      #  
+      should "fail to move a file to a non-existent directory" do
+        flunk "this actually moves the file (the file getting the name of the 'missing' directory, and I'm not sure that's wrong)"
+        not_a_dir = @dst_dir / "humblebrag"
+        
+        assert_raises( Errno::ENOENT ) do
+          @src_file.move( not_a_dir )
+        end
+      end
+      
+      should "fail to move a file owing to lack of privileges" do
+        write_protected_dir = @dst_dir / "write_protected_dir"
+        write_protected_dir.touch_dir
+        
+        temporarily_write_protect( write_protected_dir ) do
+          assert_raises( Errno::EACCES ) do
+            @src_file.move( write_protected_dir )
+          end
+        end
+      end
+    end
+    
+      
+    
+    should "fail to move a non-existent file" do
+      f = @src_dir.join( "file.txt" )
+      
+      assert_no_file( f )
+      
+      assert_raises( Errno::ENOENT ) do
+        f.move( @dst_dir )
+      end
+    end
+  end
+    
+  #
+  #   should "successfully move a directory" do
+  #     flunk "write test"
+  #   end
+  #
+  #   should "fail to move a non-existent directory" do
+  #     flunk "write test"
+  #   end
+  #
+  #   should "fail to move a directory to a non-existent directory" do
+  #     flunk "write test"
+  #   end
+  #
+  #   should "fail to move a directory owing to lack of privileges" do
+  #
+  #     flunk "write test"
+  #   end
+  # end
+  
+  def temporarily_write_protect( f, &block )
+    f.chmod( "a-w" )
+    yield
+    f.chmod( "a+w" )
+  end
+end

data/test/test_permission_methods.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+class TestPermissionMethods < FunWith::Files::TestCase
+  context "checking for availability of permission methods" do
+    setup do
+      @filepath = FunWith::Files::FilePath.new("/")
+    end
+    
+    should "have permission methods" do
+      assert_respond_to @filepath, :readable?
+      assert_respond_to @filepath, :writable?
+      assert_respond_to @filepath, :executable?
+      assert_respond_to @filepath, :chown
+      assert_respond_to @filepath, :chmod
+      assert_respond_to @filepath, :owner
+    end
+    
+    should "have a root owner" do
+      assert_equal "root", @filepath.owner
+    end
+  end
+end

data/test/test_root_path.rb

@@ -13,6 +13,15 @@ class TestRootPath < FunWith::Files::TestCase
     rootify_and_test( obj, path )
   end
   
+  context "FunWith::Files.root" do
+    should "be a directory" do
+      assert_directory( FunWith::Files.root )
+      assert_empty_directory( FunWith::Files.root( :test, :tmp ) )
+      assert_empty_directory( FunWith::Files.root / :test / :tmp )
+      assert_empty_directory( FunWith::Files.root / "test" / "tmp" )
+    end
+  end
+  
   def rootify_and_test( obj, path )
     RootPath.rootify( obj, path )
     assert obj.respond_to?(:root)

data/test/test_stat_methods.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+class TestStatMethods < FunWith::Files::TestCase
+  
+  context "checking for availability of stat-enabling methods" do
+    setup do
+      @filepath = FunWith::Files::FilePath.new("/")
+    end
+    
+    should "have stat methods" do
+      assert_respond_to @filepath, :stat
+      assert_respond_to @filepath, :inode
+      assert_respond_to @filepath, :birthtime  # this (and many others) come from Pathname
+    end
+    
+  end
+end

data/test/test_timestamping.rb

@@ -0,0 +1,74 @@
+require 'helper'
+
+class TestTimestamping < FunWith::Files::TestCase
+  context "testing timestamping" do
+    setup do
+      @tmp_dir = FunWith::Files.root( 'test', 'tmp' )
+      @logfile = @tmp_dir / "apache.log"
+      @stamp_time = Time.new( 2000, 10, 13, 23, 59, 59 )
+    end
+  
+    teardown do
+      `rm -rf #{@tmp_dir.join('*')}`
+    end
+    
+    should "sequence files with datestamps" do
+      dates = %w(2012-11-30 1900-12-01 2727-06-14)
+      
+      for date in dates
+        d = Date.new( * date.split("-").map(&:to_i) )
+        
+        f = @logfile.timestamp( format: :ymd, time: d )
+        f.write( date )
+        
+        fy = @logfile.timestamp( format: :y, time: d )
+        fy.write date[0..3]
+      end
+      
+      for str in dates + %w(2012 1900 2727)
+        file = @tmp_dir / "apache.#{str}.log"
+        assert_file file
+        assert_file_contents file, str
+      end
+    end
+
+    should "timestamp files using the timestamp() method" do
+      timestampable_file = @tmp_dir / "timestamped.dat"
+      
+      timestamped_file1  = timestampable_file.timestamp
+      timestamped_file2  = timestampable_file.timestamp( format: :y )
+
+      assert timestamped_file1 =~ /timestamped.\d{17}.dat$/
+      assert timestamped_file2 =~ /timestamped.\d{4}.dat$/
+    end
+    
+    should "raise an error when invalid format requested" do
+      f = @tmp_dir / "apache.log"
+      
+      stamped = f.timestamp
+      
+      assert_raises Errors::TimestampFormatUnrecognized do
+        f.timestamp( format: :zztop )
+      end
+      
+      # Symbols only!
+      assert_raises Errors::TimestampFormatUnrecognized do
+        f.timestamp( format: "ymd" )
+      end
+    end
+    
+    should "update the timestamp of a file that already has one" do
+      f = "apache.19931020235959000.tgz".fwf_filepath
+      timestamped_file = f.timestamp( time: @stamp_time )
+      
+      assert_equal "apache.20001013235959000.tgz", timestamped_file.path
+    end
+    
+    should "be able to give the timestamp method a custom format" do
+      fmt = Utils::TimestampFormat.new.recognizer( /^\d{2}_\d{2}_\d{2}$/ ).strftime( "%m_%d_%y" )
+      
+      timestamped_file = @logfile.timestamp( format: fmt, time: @stamp_time )
+      assert_equal "apache.10_13_00.log", timestamped_file.basename.path
+    end
+  end
+end

data/test/test_utils_bytesize.rb

@@ -0,0 +1,71 @@
+require 'helper'
+
+class TestUtilsByteSize < FunWith::Files::TestCase
+  context "testing the thing" do
+    setup do
+      @bytie = Object.new
+      @bytie.extend FunWith::Files::Utils::ByteSize
+    end
+    
+    should "respond to :to_bytes" do
+      assert_respond_to @bytie, :to_bytes
+    end
+    
+    should "accurately convert strings to bytes" do
+      assert_bytes 1_000, "1000b"
+      assert_bytes 1_000, "1 kb"
+      assert_bytes 1_000, "0.001 MB"
+      assert_bytes 1_000, "0.000001 GB"
+      
+      assert_bytes 1_234, "1234"
+      assert_bytes 1_234, "  1.234  kb  "
+      assert_bytes 9_001, "9.001k"                    # it's over 9000!
+    end
+    
+    context "converting expressions between units" do
+      should "handle simple cases" do
+        assert_converts "1KB", "B",  "1000B"
+        assert_converts "2MB", "KB", "2000KB"
+        assert_converts "3GB", "MB", "3000MB"
+        assert_converts "4TB", "GB", "4000GB"
+        assert_converts "5PB", "TB", "5000TB"
+      end
+    
+      should "be case insensitive" do
+        assert_converts "1kb", "B", "1000B"
+        assert_converts "1000k", "mb", "1mb"
+        assert_converts "1000m", "GB", "1GB"
+        assert_converts "2000 PB", " EB", "2 EB"
+      end
+
+      should "sometimes put space between number and unit" do
+        assert_converts "2000 PB", " EB", "2 EB"
+      end
+      
+      should "reflect the unit styling that the caller sends" do
+        assert_converts "1kb", "b", "1000b"     # uses the unit capitalization that the caller sends
+      end
+      
+      should "sometimes use decimal points" do
+        assert_converts "900kb", "MB", "0.9MB"
+        assert_converts "930kb", "mb", "0.9mb"
+      
+        assert_converts "99500b", "kb", "99.5kb"
+        assert_converts "1200MB", "gb", "1.2gb"
+      end
+      
+      should "sometimes not use decimal points" do
+        assert_converts "100372b", "k", "100k"
+        assert_converts "1b", "GB", "0GB"
+      end
+    end
+  end
+  
+  def assert_bytes( n, expr )
+    assert_equal n, @bytie.to_bytes( expr ), "to_bytes( #{expr} ) should resolve to #{n}"
+  end
+  
+  def assert_converts( old_expr, new_units, new_expr )
+    assert_equal new_expr, @bytie.convert( old_expr, new_units )
+  end
+end

data/test/test_utils_succession.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+class TestUtilsSuccession < FunWith::Files::TestCase
+  USucc = FunWith::Files::Utils::Succession
+  
+  context "testing Succession.get_successor_name()" do
+    should "succeed" do
+      with_digit_count( 4 ) do
+        assert_succession "file.0001.txt", "file.0002.txt" 
+        assert_succession "file.txt", "file.0000.txt" 
+        assert_succession "", "0000"
+      end
+    end
+  end
+  
+  def with_digit_count( i, &block )
+    @digit_count = i
+    yield 
+  end
+  
+  def assert_succession( input, expected )
+    if defined?( @digit_count )
+      actual = USucc.get_successor_name( input, @digit_count )
+    else
+      actual = USucc.get_successor_name( input )
+    end
+    
+    assert_equal( expected, actual, "Utils::Succession.get_successor_name() failed:\n\tinput: #{input}(#{input.class})\n\texpected: #{expected}(#{expected.class})\n\tactual: #{actual}(#{actual.class})")
+  end
+end

data/test/test_watchers.rb

@@ -0,0 +1,196 @@
+require 'helper'
+
+class TestWatchers < FunWith::Files::TestCase
+  context "testing Watcher as it benevolently watches over the files placed under its care" do
+    setup do
+      tmpdir     # assigns @tmpdir a freshly created temp directory
+      self.watch @tmpdir
+    end
+    
+    teardown do
+      @tmpdir.rm
+    end
+    
+    should "watch an empty directory as a subdirectory and a file are added" do
+      @tmpdir.touch_dir :lethe do |d|
+        file = d.join( "forgotten_file.txt" )
+        file.write( "someone help me remember this" )
+        
+        get_changes do
+          assert_changes :created, d, file
+        end
+        
+        file.append( "\nbecause I don't trust my brain to keep track of things" )
+        
+        get_changes(1) do
+          assert_changes :modified, file
+        end
+        
+        d.rm
+      
+        get_changes do
+          assert_changes :deleted, d, file
+        end
+      end  
+    end
+    
+    should "watch an empty directory as a bunch of changes happen" do
+      @tmpdir.touch_dir( :battles ) do |d0|
+        @tmpdir.touch_dir( :bunker_hill ) do |d1|
+          file0 = d1.join( "troop_movements.csv" )
+          file0.write( "My dearest Sarah,\n\tI fear this may be the last time I write to you.  Our forces are outnumbered." )
+          
+          get_changes do
+            assert_changes :created, d0, d1, file0
+          end  
+          
+          file0.append "Supplies are scarce and the horses have lost their patience with us."
+          
+          get_changes(1) do
+            assert_changes :modified, file0
+          end
+          
+          d1.rm
+          
+          get_changes(2) do
+            assert_changes :deleted, d1, file0
+          end
+        end
+        
+        d0.rm
+        
+        get_changes(1) do
+          assert_changes :deleted, d0
+        end
+      end
+    end
+    
+    should "watch for a file that doesn't exist yet" do
+      @tmpdir.touch_dir( "web_app" ) do |d|
+        watch( d.join( "restart.txt" ) )
+        
+        get_changes(0)
+        
+        restart_file = d.touch( "restart.txt" )
+        
+        get_changes(1) do
+          assert_changes :created, restart_file
+        end
+        
+        restart_file.rm
+        
+        get_changes(1) do
+          assert_changes :deleted, restart_file
+        end
+        
+        get_changes(0)
+      end
+    end
+    
+    should "build out a filesystem using DirectoryBuilder" do
+      @tmpdir.touch_dir( :ebook ) do |ebook|
+        watch ebook
+        
+        DirectoryBuilder.create( ebook ) do |builder|
+          builder.dir( :html ) do
+            builder.file "title_page.xhtml", "Make sure we get some neato art to go here."
+            builder.file "chapter1.xhtml", "Besta times, worsta times, y'know?"
+            builder.file "chapter2.xhtml", "I see a magpie perched on the roof."
+          end
+          
+          builder.dir( :css ) do
+            builder.file "main.css", "p{ background-color: painfully-pink}"
+            builder.file "title_page.css", "body{ width: 80% }"
+          end
+          
+          builder.dir( :images ) do
+            builder.file "cover.png", "We shoulda hired a graphic designer"
+          end
+        end
+        
+        html_dir = ebook / :html
+        
+        images_dir = ebook / :images
+        cover_file = images_dir / "cover.png"        
+        
+        get_changes(9) do 
+          assert_changes :created, 
+                         #  ebook,      # already existed when the watcher started
+                         html_dir, 
+                         html_dir / "title_page.xhtml",
+                         ebook / :css, 
+                         ebook / :css / "main.css",
+                         images_dir,
+                         cover_file
+        end
+        
+        cover_file.append ", Trevor worked out okay last time, can we use him again?"
+        
+        # debugger
+        
+        get_changes(2) do
+          assert_changes :modified, cover_file, images_dir, html_dir
+        end
+
+        images_dir.rm
+        
+        get_changes(2) do
+          assert_changes :deleted, images_dir, cover_file, html_dir
+        end
+      end
+    end
+    
+    should "only notice changes that aren't excluded by filters" do
+      
+      @tmpdir.touch_dir( :application_code ) do |code|
+        watch( code )
+        
+        @watcher.filter( notice: /\.cpp$/, ignore: /main.cpp$/ )
+
+        f0 = code.touch( "main.cpp" )
+        f1 = code.touch( "counter.cpp" )
+        
+        get_changes( count: 1 ) do
+          assert_changes :added, f1
+        end
+      end
+    end
+  end
+  
+  def watch( *paths )
+    @watcher = Watcher.watch( *paths ).sleep_interval( 0.01 )
+  end
+  
+  def get_changes( count: nil, expected: nil, &block )
+    @changes = @watcher.update
+    yield if block_given?
+    assert_change_count( count ) unless count.nil?
+    assert_change_set( expected ) unless expected.nil?
+  end
+  
+  def assert_changes( status, *paths )
+    assert_kind_of Hash, @changes
+    
+    oopsies = {}
+    
+    for path in paths
+      path_to_report = path.relative_path_from(@tmpdir).to_s
+      
+      if @changes.has_key?( path )
+        oopsies[path_to_report] = :change_not_reported
+      elsif status != @changes[path]
+        oopsies[path_to_report] = { :expected => status, :actual => @changes[path] } 
+      end
+      
+      unless oopsies.fwf_blank?
+        assert false, "Unexpected:" + oopsies.inspect
+      end
+    end
+  end
+  
+  def assert_change_count( i )
+    assert defined?( @changes )
+    assert_kind_of Hash, @changes
+    assert_length i, @changes
+  end
+end