fun_with_files 0.0.14 → 0.0.18

data/test/test_file_manipulation.rb

@@ -13,7 +13,7 @@ class TestFileManipulation < FunWith::Files::TestCase
     
     should "copy LICENSE.txt" do
       copied = @license.cp( "test", "tmp" )
-      assert_match /LICENSE\.txt/, copied.to_s
+      assert_match( /LICENSE\.txt/, copied.to_s ) 
       assert_file copied
       assert_file_has_content copied
     end
@@ -21,9 +21,9 @@ class TestFileManipulation < FunWith::Files::TestCase
     should "gsub copy of license.txt" do
       copied = @license.cp( "test", "tmp" )
       copied.file_gsub!( /Bryce Anderson/, "Wilford Brimley" )
-      assert copied.size > 1000
+      assert copied.size > 1000, "File is too small"
       
-      assert_file_contents copied, /Wilford Brimley/
+      assert_file_contents copied, /Wilford Brimley/, "Error 441: Wilford Brimley not found"
     end
     
     should "empty files and directories" do
@@ -120,7 +120,7 @@ class TestFileManipulation < FunWith::Files::TestCase
       
       file_def = file_abc.cp( dir_def )
       
-      assert_match /abc\.txt/, file_def.path
+      assert_match( /abc\.txt/, file_def.path )
       assert_file_contents file_def, /rent/
       
       

data/test/test_file_path.rb

@@ -10,17 +10,17 @@ class TestFilePath < FunWith::Files::TestCase
     end
     
     should "have location class methods available" do
-      assert_respond_to( FunWith::Files::FilePath, :home )
-      assert_respond_to( FunWith::Files::FilePath, :config_dir )
-      assert_respond_to( FunWith::Files::FilePath, :root )
-      assert_respond_to( FunWith::Files::FilePath, :data_dir )
+      assert_respond_to FunWith::Files::FilePath, :home 
+      assert_respond_to FunWith::Files::FilePath, :config_dir
+      assert_respond_to FunWith::Files::FilePath, :root
+      assert_respond_to FunWith::Files::FilePath, :data_dir 
     end
     
     
     should "join smoothly" do
       bin_dir = "/bin".fwf_filepath
-      assert_equal( "/bin/bash", bin_dir.join("bash").to_s )
-      assert_equal( "/bin/bash", bin_dir.join("bash".fwf_filepath).to_s )
+      assert_equal "/bin/bash", bin_dir.join("bash").to_s
+      assert_equal "/bin/bash", bin_dir.join("bash".fwf_filepath).to_s
     end
 
     should "go up/down when asked" do
@@ -32,7 +32,7 @@ class TestFilePath < FunWith::Files::TestCase
       assert_equal root, f1.up.up.up.up.up.up.up
       
       #invoking up didn't change original
-      assert_match /ask_for_floyd/, f1.to_s
+      assert_match( /ask_for_floyd/, f1.to_s )
       
       assert_equal f1, f2.down( "monkeylips" ).down( "ask_for_floyd" )
       assert_equal f1, f2.down( "monkeylips", "ask_for_floyd" )
@@ -99,17 +99,20 @@ class TestFilePath < FunWith::Files::TestCase
     should "sequence files nicely" do
       seqfile = @tmp_dir.join("sequence.txt")
       
+      files = [seqfile]
+      
       10.times do |i|
         seqfile.write( i.to_s )
         seqfile = seqfile.succ
+        files << seqfile
       end
       
-      assert_file @tmp_dir.join("sequence.txt")
-      assert_file @tmp_dir.join("sequence.000000.txt")
-      assert_file @tmp_dir.join("sequence.000008.txt")
+      assert_file files[0]
+      assert_file files[1]
+      assert_file files[9]
       
-      assert_file_contents @tmp_dir.join("sequence.txt"), "0"
-      assert_file_contents @tmp_dir.join("sequence.000008.txt"), "9"
+      assert_file_contents files[0], "0"
+      assert_file_contents files[9], "9"
     end
     
     should "sequence files with custom stamp length" do
@@ -128,35 +131,7 @@ class TestFilePath < FunWith::Files::TestCase
       assert_file_contents @tmp_dir.join("sequence.0008.txt"), "9"
     end
     
-    should "sequence files with datestamps" do
-      seqfile = @tmp_dir.join("sequence.txt")
-      
-      10.times do |i|
-        seqfile.write( i.to_s )
-        seqfile = seqfile.succ( timestamp: true )
-        sleep(0.002)
-      end
-      
-      files = seqfile.succession( timestamp: true )
-      assert files.length == 10
-      
-      files.each_with_index do |file, i|
-        assert_file file
-        assert_file_contents file, i.to_s
-      end
-      
-      file_name_strings = files.map(&:to_s)
-      assert_equal file_name_strings[1..-1], file_name_strings[1..-1].sort
-    end
 
-    should "timestamp files using the timestamp() method" do
-      timestampable_file = @tmp_dir.join( "timestamped.dat" )
-      timestamped_file1  = timestampable_file.timestamp
-      timestamped_file2  = timestampable_file.timestamp("%Y")
-
-      assert timestamped_file1 =~ /timestamped.\d{17}.dat$/
-      assert timestamped_file2 =~ /timestamped.\d{4}.dat$/
-    end
   end
   
 
@@ -216,34 +191,86 @@ class TestFilePath < FunWith::Files::TestCase
     end
   end
   
-  context "test ext()" do
+  context "testing extension methods" do
     setup do
-      @path = "hello.txt".fwf_filepath
+      @hello_path = "hello.txt".fwf_filepath
+      @dot_path0 = ".config".fwf_filepath
+      @dot_path1 = "~/.ssh".fwf_filepath
     end
     
-    should "not change path when sent nil as an argument" do
-      assert_equal @path.path, @path.ext( nil ).path
-    end
+    context "test ext()" do
     
-    should "append when given symbol" do
-      assert_equal @path.path + ".tgz", @path.ext( :tgz ).path
-    end
+      should "not change path when sent nil as an argument" do
+        assert_equal @hello_path.path, @hello_path.ext( nil ).path
+      end
+    
+      should "append when given symbol" do
+        assert_equal @hello_path.path + ".tgz", @hello_path.ext( :tgz ).path
+      end
     
-    should "append when given string" do
-      assert_equal @path.path + ".tgz", @path.ext( 'tgz' ).path
+      should "append when given string" do
+        assert_equal @hello_path.path + ".tgz", @hello_path.ext( 'tgz' ).path
+      end
+    
+      should "append correctly when given leading ." do
+        assert_equal @hello_path.path + ".tgz", @hello_path.ext( '.tgz' ).path
+      end
+    
+      should "append multiple extensions as separate args" do
+        assert_equal @hello_path.path + ".backup.tar.gz", @hello_path.ext( :backup, "tar", nil, ".gz" ).path
+      end
+    
+      should "append multiple extensions as a single string" do
+        assert_equal @hello_path.path + ".backup.tar.gz", @hello_path.ext( ".backup.tar.gz" ).path
+      end
     end
     
-    should "append correctly when given leading ." do
-      assert_equal @path.path + ".tgz", @path.ext( '.tgz' ).path
+    context "test without_ext()" do
+      setup do
+
+      end
+      
+      should "pop the extension (normal)" do
+        #debugger
+        assert_equal "hello", @hello_path.without_ext.to_s
+        assert_equal "hello", @hello_path.without_ext("txt").path
+        assert_equal "hello", @hello_path.without_ext(".txt").path
+        assert_equal "hello.txt", @hello_path.without_ext(".html").path
+        assert_equal "hello.txt", @hello_path.without_ext("html").path
+        
+        assert_equal "hello", @hello_path.without_ext(:txt).path
+      end
+      
+      should "not affect dot files" do
+        assert_equal ".config", @dot_path0.without_ext.path
+        assert_equal ".config", @dot_path0.without_ext("config").path
+        assert_equal ".config", @dot_path0.without_ext(".config").path
+        assert_equal ".config", @dot_path0.without_ext(:config).path
+      end
     end
     
-    should "append multiple extensions as separate args" do
-      assert_equal @path.path + ".backup.tar.gz", @path.ext( :backup, "tar", nil, ".gz" ).path
+    # Why does it return a filepath for the dirname piece, strings for the other two pieces?
+    context "test dirname_and_basename_and_ext" do
+    end
+  end
+  
+  context "test join()" do
+    setup do 
+      @path = "/".fwf_filepath
     end
     
-    should "append multiple extensions as a single string" do
-      assert_equal @path.path + ".backup.tar.gz", @path.ext( ".backup.tar.gz" ).path
+    should "accept all manner of arguments" do
+      expected = "/bin/0/file.rb".fwf_filepath
+      result = @path.join( :bin, 0, "file.rb" )
+      
+      assert_equal expected, result
+      
+      result = @path / :bin / 0 / "file.rb"
+      assert_equal expected, result
     end
+  end
+  
+  context "testing block form" do
     
   end
 end

data/test/test_file_requirements.rb

@@ -0,0 +1,36 @@
+require 'helper'
+
+class TestFileRequirements < FunWith::Files::TestCase
+  context "testing FileRequirements methods" do
+    setup do
+      @tmp_dir = FunWith::Files.root("test", "tmp")
+      @file    = @tmp_dir.join("file.txt").touch
+      @dir     = @tmp_dir.join("dir").touch_dir
+    end
+    
+    teardown do
+      empty_temp_directory
+    end
+    
+    context "needs_to_exist()" do
+      should "raise an error when a file doesn't exist" do
+        assert_raises Errno::ENOENT do
+          @tmp_dir.join("missing_file.txt").needs_to_exist
+        end
+      end
+      
+      should "raise an error when a file isn't empty" do
+        assert_raises Errors::FileNotEmpty do
+          @file.append("Zorpy was here")
+          @file.needs_to_be_empty
+        end
+      end
+      
+      should "raise an error when a file oughta be a directory" do
+        assert_raises Errors::NotADirectory do
+          @file.must_be_directory
+        end
+      end
+    end
+  end
+end

data/test/test_fun_with_files.rb

@@ -26,7 +26,7 @@ class TestFunWithFiles < FunWith::Files::TestCase
       assert_respond_to( FunWith::Files, :root )
       assert_respond_to( FunWith::Files, :version )
       
-      assert_equal "0.0.13", FunWith::Files.version   # Gotta change with every point release.  Ick.
+      assert_equal "0.0.17", FunWith::Files.version   # Gotta change with every point release.  Ick.
     end
   end
 end

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