rscm 0.1.0

data/test/rscm/mockit.rb

@@ -0,0 +1,130 @@
+require 'test/unit/assertions'
+
+module MockIt
+    
+  def setup
+    @to_verify = []
+  end
+  module_function :setup
+    
+  def teardown
+    super
+    if(@test_passed && @to_verify)
+      @to_verify.each{|m| m.__verify}
+    end
+  end
+
+  def new_mock
+    mock = MockIt::Mock.new
+    @to_verify = [] unless @to_verify
+    @to_verify << mock
+    mock
+  end
+
+  class Mock
+    include Test::Unit::Assertions
+    
+    def initialize
+      @expected_methods=[]
+      @expected_validation_procs=[]
+      @setup_call_procs={}
+      @unexpected_calls = []
+    end
+    
+    def __expect(method, &validation_proc)
+      validation_proc=Proc.new {|*args| nil} if validation_proc.nil?
+      @expected_methods<<method
+      @expected_validation_procs<<validation_proc
+      self
+    end
+    
+    def __setup(method, &proc)
+      proc=Proc.new {|*args| nil} if proc.nil?
+      @setup_call_procs[method]=proc
+      self
+    end
+    
+    def __verify
+      begin
+        assert_no_unexpected_calls
+        assert_all_expected_methods_called
+      ensure
+        initialize
+      end
+    end
+    
+    def method_missing(method, *args, &proc)
+      if(is_expected_call(method))
+        handle_expected_call(method, *args, &proc)
+      elsif(is_setup_call(method))
+        handle_setup_call(method, *args, &proc)
+      else
+        handle_unexpected_call(method)
+      end
+    end
+    
+    def respond_to?(method)
+      return super.respond_to?(method) if super.respond_to?(method)
+      method = symbol(method)
+      return true if is_setup_call(method)
+      return true if currently_expected_method == method
+      false
+    end
+    
+  private
+    
+    def symbol(string)
+      return nil if string==""
+      if string.is_a? String then string.intern else string end
+    end
+    
+    def assert_no_unexpected_calls
+      assert_equal([], @unexpected_calls, "got unexpected call")
+    end
+    
+    def assert_all_expected_methods_called
+      assert(@expected_validation_procs.empty?, "not all expected methods called, calls left: #{@expected_methods.inspect}")
+    end
+    
+    def is_expected_call(method)
+      @expected_methods.index(method)
+    end
+    
+    def is_setup_call(method)
+      not @setup_call_procs[method].nil?
+    end
+    
+    def handle_setup_call(method, *args, &proc)
+      @setup_call_procs[method].call(*args, &proc)
+    end
+    
+    def handle_expected_call(method, *args, &proc)
+      assert_equal(currently_expected_method, method, "got unexpected call")
+      validation_proc = current_validation_proc
+      next_call
+      validation_proc.call(*args, &proc)
+    end
+    
+    def handle_unexpected_call(method)
+      @unexpected_calls << method
+      flunk("Unexpected method invocation: #{method}")
+    end
+    
+    def currently_expected_method
+      if @expected_methods.empty? then nil 
+      else @expected_methods[0] end
+    end
+    
+    def current_validation_proc
+      if @expected_validation_procs.empty? then nil 
+      else @expected_validation_procs[0] end
+    end
+    
+    def next_call
+      @expected_methods.delete_at(0)
+      @expected_validation_procs.delete_at(0)
+    end
+    
+  end
+end
+

data/test/rscm/mockit_test.rb

@@ -0,0 +1,117 @@
+require 'test/unit'
+require 'rscm/mockit'
+
+module MockIt
+  class MockTest < Test::Unit::TestCase
+    def setup
+      @mock = Mock.new
+    end
+
+    def test_unmocked_call_fails
+      assert_raises(Test::Unit::AssertionFailedError) do
+        @mock.unmocked_call
+      end
+    end
+    
+    def test_call_to_unexpected_call_fails
+      assert_raises(Test::Unit::AssertionFailedError) do
+        @mock.expected_not_called
+      end
+    end
+
+    def test_expected_call_works
+      @mock.__expect(:expected_call)
+      @mock.expected_call
+    end
+    
+    def test_sequential_expected_methods_work
+      @mock.__expect(:expected_call1)
+      @mock.__expect(:expected_call2)
+      @mock.expected_call1
+      @mock.expected_call2
+    end
+    
+    def test_sequential_expected_methods_in_wrong_order_fails
+      @mock.__expect(:expected_call1)
+      @mock.__expect(:expected_call2)
+      assert_raises(Test::Unit::AssertionFailedError) do
+        @mock.expected_call2
+        @mock.expected_call1
+      end
+    end
+    
+    def test_provided_block_can_validate_arguments
+      @mock.__expect(:expected_call) {|arg| assert_equal("arg", arg)}
+      assert_raises(Test::Unit::AssertionFailedError) do
+        @mock.expected_call("incorrect arg")
+      end
+    end
+
+    def DOESNT_WORK_test_provided_block_can_validate_whether_block_was_given
+      @mock.__expect(:expect_call_with_block) { assert(block_given?) }
+      @mock.expect_call_with_block do end
+    end
+
+    def test_provided_block_can_validate_whether_block_was_not_given
+      @mock.__expect(:expect_call_without_block) { assert(!block_given?) }
+      @mock.expect_call_without_block
+    end
+
+    def test_provided_block_can_validate_several_arguments
+      @mock.__expect(:expected_call) {|*args| assert_equal(["arg1", "arg2"], args)}
+      @mock.expected_call("arg1", "arg2")
+    end
+    
+    def test_verify_fails_if_not_all_expected_methods_were_called
+      @mock.__expect(:expected_call)
+      assert_raises(Test::Unit::AssertionFailedError) do
+        @mock.__verify
+      end
+    end
+    
+    def test_setup_method_can_always_be_called_and_procs_returns_value
+      @mock.__setup(:setup_call) {|| :return_value}
+      assert_equal(:return_value, @mock.setup_call)
+      assert_equal(:return_value, @mock.setup_call)
+      assert_equal(:return_value, @mock.setup_call)
+    end
+    
+    def test_respond_to_gives_true_for_setups_but_not_for_others
+      @mock.__setup(:setup_method)
+      assert(@mock.respond_to?(:setup_method))
+      assert(@mock.respond_to?("setup_method"))
+      assert(!@mock.respond_to?(:other_method))
+      assert(!@mock.respond_to?("other_method"))
+    end
+    
+    def test_respond_to_gives_true_for_currently_expected_method_but_not_for_others
+      @mock.__expect(:expected_method)
+      assert(@mock.respond_to?(:expected_method))
+      assert(@mock.respond_to?("expected_method"))
+      assert(!@mock.respond_to?(:other_method))
+      assert(!@mock.respond_to?("other_method"))
+    end
+    
+    def test_can_verify_several_times_with_different_excepts
+      @mock.__expect(:expected_method)
+      @mock.expected_method
+      @mock.__verify
+      @mock.__expect(:another_expected_method)
+      @mock.another_expected_method
+      @mock.__verify
+    end
+    
+    def test_verify_fails_if_got_unexpected_call
+      assert_raises(Test::Unit::AssertionFailedError) do
+        @mock.unexpected_call
+      end
+      assert_raises(Test::Unit::AssertionFailedError) do
+        @mock.__verify
+      end
+      # should reset state after __verify
+      @mock.__verify
+    end
+    
+  end
+
+end

data/test/rscm/monotone/monotone_test.rb

@@ -0,0 +1,19 @@
+require 'test/unit'
+require 'rscm/generic_scm_tests'
+require 'rscm/monotone/monotone'
+
+module RSCM
+  class MonotoneTest < Test::Unit::TestCase
+    include GenericSCMTests
+
+    def create_scm(repository_root_dir, path)
+      mt = Monotone.new(
+        "#{repository_root_dir}/MT.db",
+        "com.example.testproject",
+        "tester@test.net",
+        "tester@test.net",
+        File.dirname(__FILE__) + "/keys"
+      )
+    end
+  end
+end

data/test/rscm/mooky/mooky_test.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require 'fileutils'
+require 'rscm/generic_scm_tests'
+require 'rscm/mooky/mooky'
+
+module RSCM
+  class MookyTest < Test::Unit::TestCase
+    include GenericSCMTests
+
+    def create_scm(repository_root_dir, path)
+      Mooky.new
+    end
+  end
+end

data/test/rscm/parser_test.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+require 'stringio'
+require 'rscm/parser'
+
+module RSCM
+  class ParserTest < Test::Unit::TestCase
+  
+    class TestParser < Parser
+      def initialize
+        super(/^-+$/)
+        @result = ""
+      end
+    
+    protected
+
+      def parse_line(line)
+        @result << line
+      end
+      
+      def next_result
+        r = @result
+        @result = ""
+        r
+      end
+    end
+  
+    def test_can_parse_until_line_inclusive
+      parser = TestParser.new
+      io = StringIO.new(TEST_DATA)
+      parser.parse(io) {|line|}
+      assert_equal("one\ntwo\n", parser.parse(io))
+      assert_equal("three\nfour\n", parser.parse(io))
+    end
+
+TEST_DATA = <<EOF
+bla bla
+--
+one
+two
+--
+three
+four
+--
+EOF
+
+  end
+end

data/test/rscm/path_converter_test.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+require 'rscm/path_converter'
+
+module RSCM
+  class PathConverterTest < Test::Unit::TestCase
+    include PathConverter
+
+    def test_should_convert_os_path_to_native_path
+      p1 = nil
+      n1 = nil
+      n2 = nil
+    
+      if(WIN32)
+        p1 = "c:\\scm\\damagecontrol"
+        n1 = p1
+        n2 = p1
+      elsif(CYGWIN)
+        p1 = "/cygdrive/c/scm/damagecontrol"
+        n1 = "c:\\scm\\damagecontrol"
+        # This format is needed when passing to an IO.popen on non-cygwin windows tools (like windows native svn)
+        n2 = "c:\\\\scm\\\\damagecontrol"
+      else
+        p1 = "/cygdrive/c/scm/damagecontrol"
+        n1 = p1
+        n2 = p1
+      end
+      assert_equal(n1, filepath_to_nativepath(p1, false))
+      assert_equal(n2, filepath_to_nativepath(p1, true))
+
+      assert_equal(p1, nativepath_to_filepath(n2))
+      assert_equal(p1, nativepath_to_filepath(n1))
+    end
+
+    def test_should_convert_os_path_to_native_url
+      path = nil
+      nativeurl = nil
+
+      if(WIN32)
+        path = "c:/scm/damagecontrol"
+        nativeurl = "file:///c:/scm/damagecontrol"
+      elsif(CYGWIN)
+        path = "/cygdrive/c/scm/damagecontrol"
+        nativeurl = "file:///c:/scm/damagecontrol"
+      else
+        path = "/cygdrive/c/scm/damagecontrol"
+        nativeurl = "file:///cygdrive/c/scm/damagecontrol"      
+      end
+      assert_equal(nativeurl, filepath_to_nativeurl(path))
+    end
+  
+  end
+end

data/test/rscm/perforce/perforce_test.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require 'rscm/generic_scm_tests'
+require 'rscm/perforce/perforce'
+
+module RSCM
+  class PerforceTest < Test::Unit::TestCase
+
+    include GenericSCMTests
+
+    def create_scm(repository_root_dir, path)
+      Perforce.new(repository_root_dir)
+    end
+  end
+end

data/test/rscm/starteam/starteam_test.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+require 'fileutils'
+require 'rscm/generic_scm_tests'
+require 'rscm/starteam/starteam'
+
+module RSCM
+  class StarTeamTest < Test::Unit::TestCase
+#    include GenericSCMTests
+
+    def create_scm(repository_root_dir, path)
+      StarTeam.new(ENV["STARTEAM_USER"], ENV["STARTEAM_PASS"], "192.168.254.21", 49201, "NGST Application", "NGST Application", "java")
+    end
+
+    def test_changesets
+      from = Time.new - 2 * 3600 * 24
+      to = Time.new - 1 * 3600 * 24
+      puts "Getting changesets for #{from} - #{to}"
+    
+      changesets = create_scm(nil, nil).changesets(nil, from, to)
+      assert_equal(1, changesets.length)
+      assert_equal(Time.utc(2004, 11, 30, 04, 52, 24), changesets[0][0].time)
+      assert_equal(Time.utc(2004, 11, 30, 04, 53, 23), changesets[0][1].time)
+      assert_equal(Time.utc(2004, 11, 30, 04, 53, 23), changesets[0].time)
+      assert_equal("rinkrank", changesets[0].developer)
+      assert_equal("En to\ntre buksa \nned\n", changesets[0].message)
+    end
+
+    def test_checkout
+      files = create_scm(nil, nil).checkout("target/starteam/checkout")
+      assert_equal(3, files.length)
+      assert_equal("eenie/meenie/minee/mo", files[0])
+      assert_equal("catch/a/redneck/by", files[1])
+      assert_equal("the/toe", files[2])
+    end
+  end
+end

data/test/rscm/svn/svn_log_parser_test.rb

@@ -0,0 +1,111 @@
+require 'test/unit'
+require 'stringio'
+require 'rscm/svn/svn_log_parser'
+
+module RSCM
+  class SVNLogParserTest < Test::Unit::TestCase
+  
+#    include FileUtils
+
+SIMPLE_LOG_ENTRY = <<EOF
+r2 | ahelleso | 2004-07-11 14:29:35 +0100 (Sun, 11 Jul 2004) | 1 line
+Changed paths:
+   M /damagecontrolled/build.xml
+   M /damagecontrolled/src/java/com/thoughtworks/damagecontrolled/Thingy.java
+
+changed something
+else
+------------------------------------------------------------------------
+EOF
+
+SIMPLE_LOG_ENTRY_WITH_BACKSLASHES = <<EOF
+r2 | ahelleso | 2004-07-11 14:29:35 +0100 (Sun, 11 Jul 2004) | 1 line
+Changed paths:
+   M \\damagecontrolled\\build.xml
+   M \\damagecontrolled\\src\\java\\com\\thoughtworks\\damagecontrolled\\Thingy.java
+
+changed something
+else
+------------------------------------------------------------------------
+EOF
+    
+    def test_can_parse_SIMPLE_LOG_ENTRIES
+      parser = SVNLogEntryParser.new("damagecontrolled", "damagecontrolled")
+      can_parse_simple_log_entry(parser, SIMPLE_LOG_ENTRY)
+      can_parse_simple_log_entry(parser, SIMPLE_LOG_ENTRY_WITH_BACKSLASHES)
+    end
+    
+    def can_parse_simple_log_entry(parser, entry)
+      changeset = parser.parse(StringIO.new(entry)) {|line|}
+
+      assert_equal(2, changeset.revision)
+      assert_equal("ahelleso", changeset.developer)
+      assert_equal(Time.utc(2004,7,11,13,29,35), changeset.time)
+      assert_equal("changed something\nelse", changeset.message)
+
+      assert_equal(2, changeset.length)
+      assert_equal("build.xml", changeset[0].path)
+      assert_equal(2, changeset[0].revision)
+      assert_equal(Change::MODIFIED, changeset[0].status)
+      assert_equal("src/java/com/thoughtworks/damagecontrolled/Thingy.java", changeset[1].path)
+      assert_equal(Change::MODIFIED, changeset[1].status)
+    end
+
+    def test_parses_entire_log_into_changesets
+      File.open(File.dirname(__FILE__) + "/proxytoys-svn.log") do |io|
+        parser = SVNLogParser.new(io, "trunk/proxytoys", nil)
+
+        changesets = parser.parse_changesets
+        
+        assert_equal(66, changesets.length)
+        # just some random assertions
+        assert_equal(
+          "DecoratingInvoker now hands off to a SimpleInvoker rather than a DelegatingInvoker if constructed with an Object to decorate.\n" +
+          "Added protected getDelegateMethod(name, params)\n", changesets[0].message)
+
+        assert_equal(66, changesets[3].revision)
+        assert_equal("tastapod", changesets[3].developer)
+        assert_equal(Time.utc(2004,05,24,17,06,18,0), changesets[3].time)
+        assert_match(/Factored delegating behaviour out/ , changesets[3].message)
+        assert_equal(15, changesets[3].length)
+
+        assert_equal("src/com/thoughtworks/proxy/toys/delegate/DelegatingInvoker.java" , changesets[3][1].path)
+        assert_equal(Change::ADDED , changesets[3][1].status)
+        assert_equal(66 , changesets[3][1].revision)
+        assert_equal(65, changesets[3][1].previous_revision)
+
+        assert_equal("src/com/thoughtworks/proxy/toys/delegate/ObjectReference.java" , changesets[3][3].path)
+        assert_equal(Change::MOVED, changesets[3][3].status)
+
+        assert_equal("src/com/thoughtworks/proxy/toys/delegate/OldDelegatingInvoker.java" , changesets[3][4].path)
+        assert_equal(Change::DELETED, changesets[3][4].status)
+
+        assert_equal("test/com/thoughtworks/proxy/toys/echo/EchoingTest.java" , changesets[3][14].path)
+        assert_equal(Change::MODIFIED , changesets[3][14].status)
+
+      end
+    end
+
+    def test_parses_entire_log_into_changesets
+      File.open(File.dirname(__FILE__) + "/cargo-svn.log") do |io|
+        parser = SVNLogParser.new(io, "trunk/proxytoys", nil)
+        changesets = parser.parse_changesets
+        assert_equal(16, changesets.length)
+      end
+    end
+
+SVN_R_LOG_HEAD_DATA = <<-EOF
+------------------------------------------------------------------------
+r48 | rinkrank | 2004-10-16 20:07:29 -0500 (Sat, 16 Oct 2004) | 1 line
+
+nothing
+------------------------------------------------------------------------
+EOF
+
+    def test_should_retrieve_head_revision
+      parser = SVNLogParser.new(StringIO.new(SVN_R_LOG_HEAD_DATA), "blah", nil)
+      changesets = parser.parse_changesets
+      assert_equal(48, changesets[0].revision)
+    end
+  end
+end