pvn 0.0.1

data/test/unit/pvn/subcommands/revision/revision_option_test.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'tc'
+require 'pvn/subcommands/revision/revision_option'
+
+module PVN
+  class RevisionOptionTestCase < PVN::TestCase
+    def assert_relative_to_absolute exp, val, path = '/Programs/wiquery/trunk'
+      ropt = PVN::RevisionOption.new
+      act = ropt.relative_to_absolute val, path
+      assert_equal exp, act, "val: #{val}; path: #{val}"
+    end
+
+    def test_relative_to_absolute_middling
+      assert_relative_to_absolute '1887', '-7'
+    end
+
+    def test_relative_to_absolute_latest
+      assert_relative_to_absolute '1950', '-1'
+    end
+
+    def test_relative_to_absolute_oldest
+      assert_relative_to_absolute '412', '-163'
+    end
+
+    def test_out_of_range
+      assert_raises(RuntimeError) do 
+        assert_relative_to_absolute '1944', '-164'
+      end
+    end
+
+    def assert_post_process exp, val, path = '/Programs/wiquery/trunk'
+      ropt = PVN::RevisionOption.new
+      ropt.set_value val
+      ropt.post_process nil, [ path ]
+      act = ropt.value
+      assert_equal exp, act, "val: #{val}; path: #{path}"
+    end
+
+    def test_post_process_absolute_middling
+      assert_post_process '1887', '1887'
+    end
+
+    def test_post_process_middling
+      assert_post_process '1887', '-7'
+    end
+
+    def test_post_process_latest
+      assert_post_process '1950', '-1'
+    end
+
+    def test_post_process_oldest
+      assert_post_process '412', '-163'
+    end
+  end
+end

data/test/unit/pvn/subcommands/revision/revision_regexp_option_test.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'tc'
+require 'pvn/subcommands/revision/revision_regexp_option'
+
+module PVN
+  class RevisionRegexpOptionTest < PVN::TestCase
+    def assert_tag_match str
+      assert_match RevisionRegexpOption::TAG_RE, str
+    end
+
+    def assert_tag_no_match str
+      assert_no_match RevisionRegexpOption::TAG_RE, str
+    end
+
+    def test_pattern
+      assert_tag_match '-r500:600'
+      assert_tag_match '+1'
+      assert_tag_match '-r 500'
+      assert_tag_match '-1776'
+
+      assert_tag_no_match ' -r500:600'
+      assert_tag_no_match '1'
+      assert_tag_no_match '123'
+      assert_tag_no_match '-x'
+    end
+
+    def test_out_of_range
+      assert_raises(RuntimeError) do 
+        ropt = PVN::RevisionRegexpOption.new
+        ropt.process [ '-164' ]
+        ropt.post_process nil, [ '/Programs/wiquery/trunk' ]
+      end
+    end
+
+    def assert_post_process exp, val, path = '/Programs/wiquery/trunk'
+      ropt = PVN::RevisionRegexpOption.new
+      ropt.set_value val
+      ropt.post_process nil, [ path ]
+      act = ropt.value
+      assert_equal exp, act, "val: #{val}; path: #{path}"
+    end
+
+    def test_post_process_middling
+      assert_post_process '1887', '-7'
+    end
+
+    def test_post_process_latest
+      assert_post_process '1950', '-1'
+    end
+
+    def test_post_process_oldest
+      assert_post_process '412', '-163'
+    end
+
+    def test_post_process_tagval
+      assert_post_process '7', '-r7'
+    end
+
+    def test_post_process_tagrange
+      assert_post_process '7:177', '-r7:177'
+    end
+
+    def test_post_process_absolute_middling
+      assert_post_process '1887', '1887'
+    end
+  end
+end

data/test/unit/svnx/info/entry_test.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'svnx/info/tc'
+require 'svnx/info/entry'
+
+module SVNx::Info
+  class EntryTestCase < SVNx::Info::TestCase
+    include Loggable
+    
+    def test_entry_from_xml
+      # svn info --xml ./wiquery-core/pom.xml
+      xml = Array.new
+      xml << '<?xml version="1.0"?>'
+      xml << '<info>'
+      xml << '<entry'
+      xml << '   kind="file"'
+      xml << '   path="wiquery-core/pom.xml"'
+      xml << '   revision="1950">'
+      xml << '<url>file:///home/jpace/Programs/Subversion/Repositories/wiquery/trunk/wiquery-core/pom.xml</url>'
+      xml << '<repository>'
+      xml << '<root>file:///home/jpace/Programs/Subversion/Repositories/wiquery</root>'
+      xml << '<uuid>9d44104b-4b85-4781-9eca-83ed02b512a0</uuid>'
+      xml << '</repository>'
+      xml << '<wc-info>'
+      xml << '<schedule>normal</schedule>'
+      xml << '<depth>infinity</depth>'
+      xml << '<text-updated>2011-11-28T11:26:07.772551Z</text-updated>'
+      xml << '<checksum>3b2a51d21a9517a4d3dc5865c4b56db9</checksum>'
+      xml << '</wc-info>'
+      xml << '<commit'
+      xml << '   revision="1907">'
+      xml << '<author>hielke.hoeve@gmail.com</author>'
+      xml << '<date>2011-11-14T10:50:38.389281Z</date>'
+      xml << '</commit>'
+      xml << '</entry>'
+      xml << '</info>'
+
+      xmllines = xml.collect { |line| line + "\n" }
+      
+      expdata = {
+        :url  => 'file:///home/jpace/Programs/Subversion/Repositories/wiquery/trunk/wiquery-core/pom.xml',
+        :kind => 'file',
+        :path => 'wiquery-core/pom.xml',
+        :root => 'file:///home/jpace/Programs/Subversion/Repositories/wiquery'
+      }
+
+      entry = Entry.new :xmllines => xmllines.join('')
+      assert_entry_equals entry, expdata
+    end
+  end
+end

data/test/unit/svnx/log/cmargs_test.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'svnx/log/tc'
+require 'svnx/log/command'
+
+module SVNx::Log
+  class CommandArgsTestCase ###$$$ < SVNx::Log::TestCase
+
+    def test_options_log_limit
+      cmdargs = LogCommandArgs.new :limit => 6
+      cmd = LogCommand.new :use_cache => true, :cmdargs => cmdargs
+      assert_equal 'svn log --xml --limit 6', cmd.command_line.to_command
+    end
+
+    def test_options_verbose
+      cmdargs = LogCommandArgs.new :verbose => true
+      cmd = LogCommand.new :use_cache => true, :cmdargs => cmdargs
+      assert_equal 'svn log --xml -v', cmd.command_line.to_command
+    end
+  end
+end

data/test/unit/svnx/log/entries_test.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'svnx/log/tc'
+require 'svnx/log/entries'
+
+module SVNx::Log
+  class EntriesTestCase < SVNx::Log::TestCase
+    include Loggable
+
+    def assert_entry_fields_not_nil entry
+      # these are occasionally missing or blank, which REXML considers nil:
+      assert entry.message
+      assert entry.author
+    end
+    
+    def test_create_from_xml
+      expdata = '1947', 'reiern70', '2011-11-14T12:24:45.757124Z', 'added a convenience method to set the range'
+      expdata << { :kind => 'file', 
+        :action => 'M', 
+        :name => '/trunk/wiquery-jquery-ui/src/test/java/org/odlabs/wiquery/ui/slider/SliderTestCase.java'
+      }
+      
+      entries = Entries.new :xmllines => get_test_lines_limit_15
+
+      assert_log_entry_equals entries[2], expdata
+    end
+
+    def test_no_author_field
+      entries = Entries.new :xmllines => get_test_lines_no_author
+      nentries = entries.size
+
+      # revision 1 has no author ... wtf?
+      assert_entry_fields_not_nil entries[0]
+    end
+
+    def test_empty_message_element
+      entries = Entries.new :xmllines => get_test_lines_empty_message
+      nentries = entries.size
+
+      # empty message here:
+      assert_entry_fields_not_nil entries[0]
+    end
+
+    def test_create_on_demand
+      # although entries now supports xmllines as an Array, we need the size for the assertion:
+      xmllines = get_test_lines_no_limit.join ''
+      
+      # quite a big file ...
+      assert_equal 324827, xmllines.size
+
+      entries = Entries.new :xmllines => xmllines
+
+      nentries = entries.size
+      assert_equal 1949, nentries
+
+      # the power of Ruby, effortlessly getting instance variables ...
+
+      real_entries = entries.instance_eval '@entries'
+
+      # nothing processed yet ...
+      assert_nil real_entries[16]
+      assert_nil real_entries[17]
+      assert_nil real_entries[18]
+
+      assert_entry_fields_not_nil entries[17]
+
+      # and these still aren't processed:
+      assert_nil real_entries[16]
+      assert_nil real_entries[18]
+    end
+  end
+end

data/test/unit/svnx/log/entry_test.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'svnx/log/tc'
+require 'svnx/log/entry'
+
+module SVNx::Log
+  class EntryTestCase < SVNx::Log::TestCase
+    include Loggable
+    
+    def test_entry_from_xml
+      expdata = '1947', 'reiern70', '2011-11-14T12:24:45.757124Z', 'added a convenience method to set the range'
+      expdata << { :kind => 'file', :action => 'M', :name => '/trunk/wiquery-jquery-ui/src/test/java/org/odlabs/wiquery/ui/slider/SliderTestCase.java' }
+
+      doc = REXML::Document.new get_test_lines_limit_15.join('')
+
+      entry = Entry.new :xmlelement => doc.elements[1].elements[3]        
+      assert_log_entry_equals entry, expdata
+    end
+  end
+end

data/test/unit/svnx/status/entry_test.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'svnx/status/tc'
+require 'svnx/status/entry'
+
+module SVNx::Status
+  class EntryTestCase < SVNx::Status::TestCase
+    include Loggable
+    
+    def test_entry_from_xml
+      xml = Array.new
+      xml << "<?xml version=\"1.0\"?>\n"
+      xml << "<status>\n"
+      xml << "<target\n"
+      xml << "   path=\"LICENSE\">\n"
+      xml << "<entry\n"
+      xml << "   path=\"LICENSE\">\n"
+      xml << "<wc-status\n"
+      xml << "   props=\"none\"\n"
+      xml << "   item=\"deleted\"\n"
+      xml << "   revision=\"1950\">\n"
+      xml << "<commit\n"
+      xml << "   revision=\"412\">\n"
+      xml << "<author>lionel.armanet</author>\n"
+      xml << "<date>2010-09-17T21:23:25.763385Z</date>\n"
+      xml << "</commit>\n"
+      xml << "</wc-status>\n"
+      xml << "</entry>\n"
+      xml << "</target>\n"
+      xml << "</status>\n"
+
+      expdata = { :path => 'LICENSE', :status => 'deleted' }
+
+      entry = Entry.new :xmllines => xml.join('')
+      assert_entry_equals entry, expdata
+    end
+  end
+end

data/test/unit/synoption/base_option_test.rb

@@ -0,0 +1,182 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'tc'
+require 'synoption/base_option'
+require 'stringio'
+
+module PVN
+  class BaseOptionTestCase < Test::Unit::TestCase
+    include Loggable
+    
+    def test_init_minimal
+      opt = BaseOption.new :limit, '-l', "the number of log entries", nil
+      assert_equal :limit, opt.name
+      assert_equal '-l', opt.tag
+      assert_equal "the number of log entries", opt.description
+    end
+
+    def test_init_default_value
+      opt = BaseOption.new :nombre, '-x', " one two three", 133
+      assert_equal 133, opt.value
+    end
+
+    def test_init_negate
+      opt = BaseOption.new :limit, '-l', "the number of log entries", nil, :negate => [ %r{^--no-?limit} ]
+      assert_equal [ %r{^--no-?limit} ], opt.negate
+    end
+
+    def test_to_doc
+      opt = BaseOption.new :limit, '-l', "the number of log entries", 777, :negate => [ %r{^--no-?limit} ]
+      sio = StringIO.new
+      opt.to_doc sio
+      exp = String.new
+      exp << "  -l [--limit] ARG         : the number of log entries\n"
+      exp << "                               default: 777\n"
+      exp << "  --no-limit                 \n"
+      assert_equal exp, sio.string
+    end
+
+    def assert_exact_match exp, opt, val
+      assert_equal exp, opt.exact_match?(val), "value: '" + val + "'"
+    end
+
+    def test_exact_match
+      opt = BaseOption.new :limit, '-l', "the number of log entries", 3
+      [ '-l', '--limit' ].each do |val|
+        assert_exact_match true, opt, val
+      end
+
+      [ '-L', '-x', '--lim', '--liMit' ].each do |val|
+        assert_exact_match false, opt, val
+      end
+    end
+
+    def assert_negative_match exp, opt, val
+      md = opt.negative_match? val
+      assert_equal exp, !!md, "value: '" + val + "'"
+    end
+
+    def test_negative_match
+      opt = BaseOption.new :limit, '-l', "the number of log entries", 777, :negate => [ '-L', %r{^--no-?limit} ]
+      [ '-L', '--no-limit', '--nolimit' ].each do |val|
+        assert_negative_match true, opt, val
+      end
+
+      [ '-l', '-x', '-nolimit', '  --nolimit' ].each do |val|
+        assert_negative_match false, opt, val
+      end
+    end
+
+    def assert_regexp_match exp, opt, val
+      md = opt.regexp_match? val
+      assert_equal exp, !!md, "value: '" + val + "'"
+    end
+
+    def test_regexp_match
+      opt = BaseOption.new :revision, '-r', "the revision", nil, :regexp => Regexp.new('^[\-\+]\d+$')
+      [ '-1', '-123', '+99', '+443' ].each do |val|
+        assert_regexp_match true, opt, val
+      end
+
+      [ '-x', '123', '+-x', 'word' ].each do |val|
+        assert_regexp_match false, opt, val
+      end
+    end
+
+    def assert_to_command_line exp, opt
+      assert_equal exp, opt.to_command_line
+    end
+
+    def make_xyz_option options = Hash.new
+      BaseOption.new :xyz, '-x', "the blah blah blah", nil, options
+    end
+
+    def test_to_command_line_no_cmdline_option
+      opt = make_xyz_option
+      assert_to_command_line nil, opt
+      opt.set_value 1
+      assert_to_command_line [ '-x', 1 ], opt
+    end
+
+    def test_to_command_line_cmdline_option_string
+      opt = make_xyz_option :as_cmdline_option => '--xray'
+      assert_to_command_line nil, opt
+      opt.set_value 1
+      assert_to_command_line '--xray', opt
+    end
+
+    def test_to_command_line_cmdline_option_nil
+      opt = make_xyz_option :as_cmdline_option => nil
+      assert_to_command_line nil, opt
+      opt.set_value 1
+      assert_to_command_line nil, opt
+    end
+
+    def test_takes_value
+      opt = make_xyz_option
+      assert opt.takes_value?
+    end
+
+    def assert_process exp_process, exp_value, exp_remaining_args, opt, args
+      pr = opt.process args
+      assert_equal exp_process, pr
+      assert_equal exp_value, opt.value
+      assert_equal exp_remaining_args, args
+    end
+
+    def test_process_exact_no_match
+      opt = make_xyz_option
+      args = %w{ --baz foo }
+      assert_process false, nil, %w{ --baz foo }, opt, args
+    end
+
+    def test_process_exact_takes_argument
+      opt = make_xyz_option
+      args = %w{ --xyz foo }
+      assert_process true, 'foo', %w{ }, opt, args
+
+      opt = make_xyz_option
+      args = %w{ --xyz foo bar }
+      assert_process true, 'foo', %w{ bar }, opt, args
+    end
+
+    def test_process_exact_takes_missing_argument
+      opt = make_xyz_option
+      args = %w{ --xyz }
+      assert_raises(RuntimeError) do 
+        assert_process true, 'foo', %w{ }, opt, args
+      end
+    end
+
+    def test_process_negative
+      options = { :negate => [ '-X', %r{^--no-?xyz} ] }
+      %w{ -X --no-xyz --noxyz }.each do |arg|
+        opt = make_xyz_option options
+        args = [ arg ]
+        assert_process true, false, %w{ }, opt, args
+      end
+
+      %w{ -X --no-xyz --noxyz }.each do |arg|
+        opt = make_xyz_option options
+        args = [ arg, '--abc' ]
+        assert_process true, false, %w{ --abc }, opt, args
+      end
+    end
+
+    def test_process_regexp
+      options = { :regexp => Regexp.new('^[\-\+]\d+$') }
+      %w{ -1 +123 }.each do |arg|
+        opt = make_xyz_option options
+        args = [ arg ]
+        assert_process true, arg, %w{ }, opt, args
+      end
+
+      %w{ -1 +123 }.each do |arg|
+        opt = make_xyz_option options
+        args = [ arg, '--foo' ]
+        assert_process true, arg, %w{ --foo }, opt, args
+      end
+    end
+  end
+end

data/test/unit/synoption/match_test.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'tc'
+require 'synoption/match'
+
+module PVN
+  class MatchTestCase < Test::Unit::TestCase
+    include Loggable
+
+    def assert_match exp, matcher, arg
+      assert_equal exp, matcher.match?(arg), "arg: #{arg}"
+    end
+
+    def assert_matches exp, matcher, *args
+      args.each do |arg|
+        assert_match exp, matcher, arg
+      end
+    end
+
+    def test_exact
+      matcher = OptionExactMatch.new '-t', 'tagname'
+      assert_matches true,  matcher, '-t', '--tagname'
+      assert_matches false, matcher, '-T', '--tag-name', '--no-tagname', '--notagname'
+    end
+
+    def test_negative_string
+      matcher = OptionNegativeMatch.new '-T'
+      assert_matches true,  matcher, '-T'
+      assert_matches false, matcher, '-t'
+    end
+
+    def test_negative_regexp
+      matcher = OptionNegativeMatch.new %r{^\-\-no\-?tagname$}
+      assert_matches true,  matcher, '--no-tagname', '--notagname'
+      assert_matches false, matcher, '-t', '--non-tagname' '--nontagname'
+    end
+
+    def test_negative_multiple
+      matcher = OptionNegativeMatch.new %r{^\-\-no\-?tagname$}, '-T'
+      assert_matches true,  matcher, '-T', '--no-tagname', '--notagname'
+      assert_matches false, matcher, '-t', '--tagname'
+    end
+
+    def assert_match_not_nil matcher, arg
+      assert_not_nil matcher.match?(arg), "arg: #{arg}"
+    end
+
+    def assert_matches_not_nil matcher, *args
+      args.each do |arg|
+        assert_match_not_nil matcher, arg
+      end
+    end
+
+    def test_regexp_match
+      matcher = OptionRegexpMatch.new %r{^--tag-?name$}
+      assert_matches_not_nil matcher, '--tagname', '--tag-name'
+      assert_matches nil,    matcher, '--tagnames' '--tag--name'
+    end
+  end
+end

data/test/unit/synoption/option_test.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'tc'
+require 'synoption/option'
+require 'stringio'
+
+module PVN
+  class OptionTestCase < Test::Unit::TestCase
+    include Loggable
+    
+    def test_nothing_yet
+    end
+  end
+end

data/test/unit/synoption/set_test.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'tc'
+require 'synoption/set'
+require 'synoption/base_option'
+require 'stringio'
+
+module PVN
+  class SetTestCase < Test::Unit::TestCase
+    include Loggable
+
+    def test_find_by_name
+      xyz = BaseOption.new :xyz, '-x', "blah blah xyz",    nil
+      abc = BaseOption.new :abc, '-a', "abc yadda yadda",  nil
+      tnt = BaseOption.new :tnt, '-t', "tnt and so forth", nil
+      
+      os = OptionSet.new [ xyz, abc, tnt ]
+      
+      assert_not_nil os.find_by_name(:xyz)
+      assert_nil os.find_by_name(:bfd)
+    end
+
+    def test_
+      xyz = BaseOption.new :xyz, '-x', "blah blah xyz",    nil
+      abc = BaseOption.new :abc, '-a', "abc yadda yadda",  nil
+      tnt = BaseOption.new :tnt, '-t', "tnt and so forth", nil
+      
+      os = OptionSet.new [ xyz, abc, tnt ]
+      
+      assert_not_nil os.find_by_name(:xyz)
+      assert_nil os.find_by_name(:bfd)
+
+      assert_equal xyz, os.find_by_name(:xyz)
+    end
+  end
+end