esr-rim 1.1.5

data/test/sync_helper_test.rb

@@ -0,0 +1,193 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+$:.unshift File.join(File.dirname(__FILE__))
+
+require 'minitest/autorun'
+require 'rim/git'
+require 'rim/module_info'
+require 'rim/status_builder'
+require 'rim/sync_helper'
+require 'test_helper'
+require 'fileutils'
+
+class SyncHelperTest < Minitest::Test
+  include FileUtils
+  include TestHelper
+
+  def setup
+    test_dir = empty_test_dir("sync_helper_test")
+    @remote_git_dir = File.join(test_dir, "remote_git")
+    @ws_remote_dir = File.join(test_dir, "remote_ws")
+    @ws_dir = File.join(test_dir, "ws")
+    @logger = Logger.new($stdout)
+    @logger.level = Logger::ERROR unless ARGV.include? "debug"
+    RIM::GitSession.logger = @logger
+  end
+  
+  def teardown
+    remove_test_dirs
+  end
+
+  def test_files_are_synchronized
+    mod1_info = create_module_git("mod1")
+    mod2_info = create_module_git("mod2")
+    create_ws_git("testbr")
+    cut = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info, mod2_info])
+    cut.sync
+    RIM::git_session(@ws_dir) do |s|
+      assert !File.exist?(File.join(@ws_dir, "mod1"))
+      assert !File.exist?(File.join(@ws_dir, "mod2"))
+      s.execute("git checkout rim/testbr")
+      check_not_dirty(s)
+      log = s.execute("git log | grep \" module \"").split("\n").sort
+      assert log.size == 2
+      assert log[0].include?("mod1")
+      assert log[1].include?("mod2")
+      assert File.exist?(File.join(@ws_dir, "mod1"))
+      assert File.exist?(File.join(@ws_dir, "mod2"))
+    end
+  end
+
+  def test_files_are_synchronized_on_existing_branch
+    mod1_info = create_module_git("mod1")
+    mod2_info = create_module_git("mod2")
+    create_ws_git("testbr")
+    cut = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info, mod2_info])
+    cut.sync
+    `echo ' changed' >> #{File.join(@ws_dir, "readme")}`
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git commit . -m \"Changed ws file\"")
+    end
+    remote_path = path_from_module_info(mod1_info)
+    `echo ' changed' >> #{File.join(remote_path, "readme.txt")}`
+    RIM::git_session(remote_path) do |f|
+      f.execute("git commit . -m \"Changed mod1 file\"")
+    end
+    cut.sync
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git checkout rim/testbr")
+      check_not_dirty(s)
+      log = s.execute("git log | grep \" module \"").split("\n").sort
+      assert log.size == 3
+      assert log[0].include?("mod1")
+      assert log[1].include?("mod1")
+      assert log[2].include?("mod2")
+      assert File.exist?(File.join(@ws_dir, "mod1"))
+      `cat #{File.join(@ws_dir, "mod1/readme.txt")}`.start_with?("Content. changed")
+      assert File.exist?(File.join(@ws_dir, "mod2"))
+    end
+  end
+  
+  def test_files_are_synchronized_on_new_branch_if_behind_last_remote_commit
+    mod1_info = create_module_git("mod1")
+    mod2_info = create_module_git("mod2")
+    create_ws_git("testbr")
+    cut = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info, mod2_info])
+    cut.sync
+    `echo ' changed' >> #{File.join(@ws_remote_dir, "readme")}`
+    RIM::git_session(@ws_remote_dir) do |s|
+      s.execute("git commit . -m \"Changed ws file\"")
+    end
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git pull")
+      assert !has_ancestor?(s, "rim/testbr", "testbr")
+    end
+    cut.sync
+    RIM::git_session(@ws_dir) do |s|
+      assert has_ancestor?(s, "rim/testbr", "testbr")
+    end
+  end
+  
+  def test_existing_non_ignored_files_are_removed_during_sync
+    mod1_info = create_module_git("mod1")
+    create_ws_git("testbr") do |s|
+      FileUtils.mkdir_p(File.join(@ws_remote_dir, "mod1"))
+      File.open(File.join(@ws_remote_dir, "mod1", "existing.txt"), "w") do |f|
+        f.write("Content")
+      end
+      s.execute("git add --all mod1")
+      s.execute("git commit -m \"Create existing file within mod1\"")
+    end
+    cut = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info])
+    cut.sync
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git rebase rim/testbr")
+      assert !File.exists?(File.join(@ws_dir, "mod1", "existing.txt"))
+    end
+  end
+  
+  def test_case_change_in_filename_is_synced_correctly
+    mod1_info = create_module_git("mod1")
+    create_ws_git("testbr")
+    cut = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info])
+    cut.sync
+    remote_path = path_from_module_info(mod1_info)
+    RIM::git_session(remote_path) do |s|
+      FileUtils.mv(File.join(remote_path, "readme.txt"), File.join(remote_path, "readme.tx_"))
+      s.execute("git add --all .")
+      s.execute("git commit -m \"Temporary change of filename within mod1\"")
+      FileUtils.mv(File.join(remote_path, "readme.tx_"), File.join(remote_path, "Readme.txt"))
+      s.execute("git add --all .")
+      s.execute("git commit -m \"Changed case in filename within mod1\"")
+    end
+    cut.sync
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git rebase rim/testbr")
+      out = s.execute("git show --name-only")
+      assert out.include?("readme.txt")
+      assert out.include?("Readme.txt")
+    end
+  end
+
+private
+  def create_ws_git(branch = "master")
+    FileUtils.mkdir_p(@ws_remote_dir)
+    RIM::git_session(@ws_remote_dir) do |s|
+      s.execute("git init")
+      s.execute("git checkout -B #{branch}")
+      File.open(File.join(@ws_remote_dir, ".gitignore"), "w") do |f| 
+        f.write(".rim") 
+      end
+      File.open(File.join(@ws_remote_dir, "readme"), "w") do |f|
+        f.write("Content")
+      end
+      s.execute("git add .")
+      s.execute("git commit -m \"Initial commit\"")
+      yield s if block_given?
+    end
+    FileUtils.mkdir_p(@ws_dir)
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git clone #{@ws_remote_dir} #{@ws_dir}")
+    end
+  end
+
+  def create_module_git(name, branch = "master")
+    git_dir = File.join(@remote_git_dir, name)
+    FileUtils.mkdir_p(git_dir)
+    RIM::git_session(git_dir) do |s|
+      s.execute("git init")
+      s.execute("git checkout -B #{branch}")
+      File.open(File.join(git_dir, "readme.txt"), "w") do |f| 
+        f.write("Content.") 
+      end
+      s.execute("git add .")
+      s.execute("git commit -m \"Initial commit\"")
+    end
+    return RIM::ModuleInfo.new("file://" + git_dir, name, branch)
+  end
+
+  def path_from_module_info(module_info)
+    module_info.remote_url.gsub(/^file:\/\//, "")
+  end
+
+  def check_not_dirty(session)
+    status = RIM::StatusBuilder.new.rev_status(session, "HEAD")
+    status.modules.each do |m|
+      assert !m.dirty?
+    end    
+  end
+  
+  def has_ancestor?(session, rev, ancestor)
+    rev = session.execute("git rev-list #{rev}").include?(session.rev_sha1(ancestor))
+  end
+  
+end

data/test/sync_module_helper_test.rb

@@ -0,0 +1,96 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+$:.unshift File.join(File.dirname(__FILE__))
+
+require 'minitest/autorun'
+require 'rim/git'
+require 'rim/dirty_check'
+require 'rim/module_info'
+require 'rim/sync_module_helper'
+require 'test_helper'
+require 'fileutils'
+
+class SyncModuleHelperTest < Minitest::Test
+  include FileUtils
+  include TestHelper
+
+  def setup
+    @logger = Logger.new($stdout)
+    @logger.level = Logger::ERROR unless ARGV.include? "debug"
+    RIM::GitSession.logger = @logger
+    test_dir = empty_test_dir("module_sync_helper_test")
+    remote_git_dir = File.join(test_dir, "remote_git")
+    @remote_git_dir = "file://" + remote_git_dir
+    FileUtils.mkdir(remote_git_dir)
+    RIM::git_session(remote_git_dir) do |s|
+      s.execute("git init")
+      s.execute("git checkout -B testbr")
+      write_file(remote_git_dir, "readme.txt")
+      s.execute("git add .")
+      s.execute("git commit -m \"Initial commit\"")
+    end
+    @ws_dir = File.join(test_dir, "ws")
+    FileUtils.mkdir(@ws_dir)
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git clone #{@remote_git_dir} .")
+    end
+  end
+  
+  def teardown
+    remove_test_dirs
+  end
+
+  def test_files_are_copied_to_working_dir
+    info = RIM::ModuleInfo.new(@remote_git_dir, "test", "testbr")
+    cut = RIM::SyncModuleHelper.new(@ws_dir, @ws_dir, info, @logger)
+    cut.sync
+    assert File.exists?(File.join(@ws_dir, "test/readme.txt"))
+    assert File.exists?(File.join(@ws_dir, "test/.riminfo"))
+  end
+
+  def test_files_of_ignore_list_are_not_removed_when_copying
+    test_folder = File.join(@ws_dir, "test")
+    write_file(test_folder, "file1")
+    write_file(test_folder, "file2")
+    write_file(File.join(test_folder, "folder"), "file1")
+    write_file(File.join(test_folder, "folder"), "file2")
+    write_file(File.join(test_folder, "folder2"), "file1")
+    info = RIM::ModuleInfo.new(@remote_git_dir, "test", "testbr", "**/file2")
+    cut = RIM::SyncModuleHelper.new(@ws_dir, @ws_dir, info, @logger)
+    cut.sync
+    assert File.exists?(File.join(test_folder, "readme.txt"))
+    assert File.exists?(File.join(test_folder, ".riminfo"))
+    assert !File.exists?(File.join(test_folder, "file1"))
+    assert File.exists?(File.join(test_folder, "file2"))
+    assert !File.exists?(File.join(test_folder, "folder/file1"))
+    assert File.exists?(File.join(test_folder, "folder/file2"))
+    assert File.exists?(File.join(test_folder, "folder/file2"))
+  end
+
+  def test_commit_message_is_set_by_default
+    info = RIM::ModuleInfo.new(@remote_git_dir, "test", "testbr")
+    cut = RIM::SyncModuleHelper.new(@ws_dir, @ws_dir, info, @logger)
+    cut.sync
+    RIM::git_session(@ws_dir) do |s|
+      out = s.execute("git log HEAD~1..HEAD")
+      assert out.include?("rim sync: module")
+    end
+  end
+
+  def test_commit_message_can_be_changed
+    info = RIM::ModuleInfo.new(@remote_git_dir, "test", "testbr")
+    cut = RIM::SyncModuleHelper.new(@ws_dir, @ws_dir, info, @logger)
+    cut.sync("This is the commit header.")
+    RIM::git_session(@ws_dir) do |s|
+      out = s.execute("git log HEAD~1..HEAD")
+      assert out.include?("This is the commit header.\n")
+    end
+  end
+
+  def write_file(dir, name)
+    FileUtils.mkdir_p(dir)
+    File.open(File.join(dir, name), "w") do |f| 
+      f.write("Content of #{name}\n") 
+    end
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,39 @@
+require 'fileutils'
+
+module TestHelper
+
+def create_rim_info(dir, attrs)
+  FileUtils.mkdir_p dir
+  ri = RIM::RimInfo.new
+  attrs.each_pair do |k,v|
+    ri.send("#{k}=", v)
+  end
+  ri.to_dir(dir)
+end
+
+def empty_test_dir(dir)
+  # create directory in test folder
+  dir = File.dirname(__FILE__)+"/"+dir
+  rm_rf(dir)
+  mkdir_p(dir)
+  @test_dirs ||= []
+  @test_dirs << dir
+  dir
+end
+
+def write_file(path, content)
+  FileUtils.mkdir_p File.dirname(path)
+  File.open(path, "w") do |f| 
+    f.write content
+  end
+end
+
+def remove_test_dirs
+  @test_dirs ||= []
+  @test_dirs.each do |d|
+    rm_rf(d)
+  end
+  @test_dirs = nil
+end
+
+end

data/test/unit_tests.rb

@@ -0,0 +1,14 @@
+$:.unshift File.join(File.dirname(__FILE__))
+
+# include all unit tests here
+require 'manifest_helper_test'
+require 'file_helper_test'
+require 'rim_info_test'
+require 'dirty_check_test'
+require 'status_builder_test'
+require 'processor_test'
+require 'sync_module_helper_test'
+require 'sync_helper_test'
+require 'upload_module_helper_test'
+require 'upload_helper_test'
+require 'git_test'

data/test/upload_helper_test.rb

@@ -0,0 +1,338 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+$:.unshift File.join(File.dirname(__FILE__))
+
+require 'minitest/autorun'
+require 'rim/git'
+require 'rim/module_info'
+require 'rim/rim_info'
+require 'rim/status_builder'
+require 'rim/sync_helper'
+require 'rim/upload_helper'
+require 'test_helper'
+require 'fileutils'
+
+class UploadHelperTest < Minitest::Test
+  include FileUtils
+  include TestHelper
+
+  def setup
+    test_dir = empty_test_dir("upload_helper_test")
+    @remote_git_dir = File.join(test_dir, "remote_git")
+    @ws_remote_dir = File.join(test_dir, "remote_ws")
+    @ws_dir = File.join(test_dir, "ws")
+    @logger = Logger.new($stdout)
+    @logger.level = Logger::ERROR unless ARGV.include? "debug"
+    RIM::GitSession.logger = @logger
+  end
+  
+  def teardown
+    remove_test_dirs
+  end
+
+  def test_no_files_are_uploaded_if_not_dirty
+    mod1_info = create_module_git("mod1")
+    sha1 = nil
+    module_session(mod1_info) do |s|
+      sha1 = s.rev_sha1("HEAD")  
+    end 
+    mod2_info = create_module_git("mod2")
+    create_ws_git("testbr")
+    sync_helper = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info, mod2_info])
+    sync_helper.sync
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git rebase rim/testbr")
+    end
+    cut = RIM::UploadHelper.new(@ws_dir, true, @logger, [mod1_info, mod2_info])
+    cut.upload
+    module_session(mod1_info) do |s|
+      assert s.rev_sha1("master") == sha1
+    end
+  end
+  
+  def test_files_of_new_commits_are_uploaded
+    mod1_info = create_module_git("mod1")
+    create_ws_git("testbr")
+    sync_helper = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info])
+    sync_helper.sync
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git rebase rim/testbr")
+    end
+    shas = []
+    # make two changes to module
+    RIM::git_session(@ws_dir) do |s|
+      `echo ' appended' >> #{File.join(@ws_dir, "mod1/readme.txt")}`
+      s.execute("git commit . -m \"First change\"")
+      shas.push(s.rev_sha1("HEAD"))  
+      `echo 'Test' > #{File.join(@ws_dir, "mod1/new_file.txt")}`
+      s.execute("git add .")
+      s.execute("git commit . -m \"Second change\"")
+      shas.push(s.rev_sha1("HEAD"))  
+    end
+    cut = RIM::UploadHelper.new(@ws_dir, true, @logger, [mod1_info])
+    cut.upload
+    module_session(mod1_info) do |s|
+      s.execute("git checkout master")
+      assert File.exist?(File.join(@remote_git_dir, "mod1/readme.txt"))
+      assert File.exist?(File.join(@remote_git_dir, "mod1/new_file.txt"))
+      assert s.execute("git show -s --format=%B HEAD").start_with?("Second change")
+      assert s.execute("git show -s --format=%B HEAD~1").start_with?("First change") 
+    end
+  end
+
+  def test_files_of_new_commits_are_uploaded_to_push_branch
+    mod1_info = create_module_git("mod1", "master", "for/%s")
+    create_ws_git("testbr")
+    sync_helper = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info])
+    sync_helper.sync
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git rebase rim/testbr")
+    end
+    shas = []
+    # make two changes to module
+    RIM::git_session(@ws_dir) do |s|
+      `echo ' appended' >> #{File.join(@ws_dir, "mod1/readme.txt")}`
+      s.execute("git commit . -m \"First change\"")
+      shas.push(s.rev_sha1("HEAD"))  
+      `echo 'Test' > #{File.join(@ws_dir, "mod1/new_file.txt")}`
+      s.execute("git add .")
+      s.execute("git commit . -m \"Second change\"")
+      shas.push(s.rev_sha1("HEAD"))  
+    end
+    cut = RIM::UploadHelper.new(@ws_dir, true, @logger, [mod1_info])
+    cut.upload
+    module_session(mod1_info) do |s|
+      s.execute("git checkout for/master")
+      assert File.exist?(File.join(@remote_git_dir, "mod1/readme.txt"))
+      assert File.exist?(File.join(@remote_git_dir, "mod1/new_file.txt"))
+      assert s.execute("git show -s --format=%B HEAD").start_with?("Second change")
+      assert s.execute("git show -s --format=%B HEAD~1").start_with?("First change") 
+    end
+  end
+
+  def test_files_of_new_commits_are_uploaded_to_direct_branch
+    mod1_info = create_module_git("mod1", "master", "for/%s")
+    create_ws_git("testbr")
+    sync_helper = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info])
+    sync_helper.sync
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git rebase rim/testbr")
+    end
+    shas = []
+    # make two changes to module
+    RIM::git_session(@ws_dir) do |s|
+      `echo ' appended' >> #{File.join(@ws_dir, "mod1/readme.txt")}`
+      s.execute("git commit . -m \"First change\"")
+      shas.push(s.rev_sha1("HEAD"))  
+      `echo 'Test' > #{File.join(@ws_dir, "mod1/new_file.txt")}`
+      s.execute("git add .")
+      s.execute("git commit . -m \"Second change\"")
+      shas.push(s.rev_sha1("HEAD"))  
+    end
+    cut = RIM::UploadHelper.new(@ws_dir, false, @logger, [mod1_info])
+    cut.upload
+    module_session(mod1_info) do |s|
+      s.execute("git checkout master")
+      assert File.exist?(File.join(@remote_git_dir, "mod1/readme.txt"))
+      assert File.exist?(File.join(@remote_git_dir, "mod1/new_file.txt"))
+      assert s.execute("git show -s --format=%B HEAD").start_with?("Second change")
+      assert s.execute("git show -s --format=%B HEAD~1").start_with?("First change") 
+    end
+  end
+  
+  def test_files_of_new_commits_are_uploaded_without_ignores
+    mod1_info = create_module_git("mod1")
+    create_ws_git("testbr")
+    sync_helper = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info])
+    sync_helper.sync
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git rebase rim/testbr")
+    end
+    shas = []
+    # make two changes to module
+    RIM::git_session(@ws_dir) do |s|
+      `echo ' appended' >> #{File.join(@ws_dir, "mod1/readme.txt")}`
+      s.execute("git commit . -m \"First change\"")
+      shas.push(s.rev_sha1("HEAD"))  
+      `echo 'Test' > #{File.join(@ws_dir, "mod1/new_file.txt")}`
+      # Adjust rim_info to contain the file as ignored file
+      rim_info = RIM::RimInfo.from_dir(File.join(@ws_dir, "mod1"))
+      rim_info.ignores = "new_file.txt"
+      rim_info.to_dir(File.join(@ws_dir, "mod1"))
+      `echo 'Test' > #{File.join(@ws_dir, "mod1/new_file2.txt")}`
+      s.execute("git add .")
+      s.execute("git commit . -m \"Second change\"")
+      shas.push(s.rev_sha1("HEAD"))  
+    end
+    cut = RIM::UploadHelper.new(@ws_dir, true, @logger, [mod1_info])
+    cut.upload
+    module_session(mod1_info) do |s|
+      s.execute("git checkout master")
+      assert File.exist?(File.join(@remote_git_dir, "mod1/readme.txt"))
+      assert !File.exist?(File.join(@remote_git_dir, "mod1/new_file.txt"))
+      assert File.exist?(File.join(@remote_git_dir, "mod1/new_file2.txt"))
+      assert s.execute("git show -s --format=%B HEAD").start_with?("Second change")
+      assert s.execute("git show -s --format=%B HEAD~1").start_with?("First change")
+    end
+  end
+
+  def test_files_of_amended_commits_are_uploaded
+    mod1_info = create_module_git("mod1")
+    create_ws_git("testbr")
+    sync_helper = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info])
+    sync_helper.sync
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git rebase rim/testbr")
+    end
+    shas = []
+    # make two changes to module
+    RIM::git_session(@ws_dir) do |s|
+      `echo ' appended' >> #{File.join(@ws_dir, "mod1/readme.txt")}`
+      s.execute("git commit . -m \"First change\"")
+      shas.push(s.rev_sha1("HEAD"))  
+      `echo 'Test' > #{File.join(@ws_dir, "mod1/new_file.txt")}`
+      `echo 'Test' > #{File.join(@ws_dir, "mod1/new_file2.txt")}`
+      s.execute("git add .")
+      s.execute("git commit . -m \"Second change\"")
+      shas.push(s.rev_sha1("HEAD"))  
+    end
+    cut = RIM::UploadHelper.new(@ws_dir, true, @logger, [mod1_info])
+    cut.upload
+    module_session(mod1_info) do |s|
+      s.execute("git checkout master")
+      assert File.exist?(File.join(@remote_git_dir, "mod1/readme.txt"))
+      assert File.exist?(File.join(@remote_git_dir, "mod1/new_file.txt"))
+      assert File.exist?(File.join(@remote_git_dir, "mod1/new_file2.txt"))
+      assert s.execute("git show -s --format=%B HEAD").start_with?("Second change")
+      assert s.execute("git show -s --format=%B HEAD~1").start_with?("First change")
+      s.execute("git checkout --detach master")
+      s.execute("git branch -D master")
+    end
+    # reset testbr now on previous commit and commit new change
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git checkout -B testbr HEAD~1")
+      `echo 'Test' > #{File.join(@ws_dir, "mod1/test_file.txt")}`
+      s.execute("git add .")
+      s.execute("git commit . -m \"Third change\"")      
+    end
+    cut.upload
+    module_session(mod1_info) do |s|
+      s.execute("git checkout master")
+      assert File.exist?(File.join(@remote_git_dir, "mod1/readme.txt"))
+      assert File.exist?(File.join(@remote_git_dir, "mod1/test_file.txt"))
+      assert !File.exist?(File.join(@remote_git_dir, "mod1/new_file.txt"))
+      assert !File.exist?(File.join(@remote_git_dir, "mod1/new_file2.txt"))
+      assert s.execute("git show -s --format=%B HEAD").start_with?("Third change")
+      assert s.execute("git show -s --format=%B HEAD~1").start_with?("First change")
+    end
+  end
+
+  def test_files_of_merged_commits_are_uploaded
+    mod1_info = create_module_git("mod1")
+    create_ws_git("testbr")
+    sync_helper = RIM::SyncHelper.new(@ws_dir, @logger, [mod1_info])
+    sync_helper.sync
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git rebase rim/testbr")
+    end
+    shas = []
+    # make two changes to module
+    RIM::git_session(@ws_dir) do |s|
+      `echo ' appended' >> #{File.join(@ws_dir, "mod1/readme.txt")}`
+      s.execute("git commit . -m \"First change\"")
+      #shas.push(s.rev_sha1("HEAD"))  
+      `echo 'Test' > #{File.join(@ws_dir, "mod1/new_file.txt")}`
+      `echo 'Test' > #{File.join(@ws_dir, "mod1/new_file2.txt")}`
+      s.execute("git add .")
+      s.execute("git commit . -m \"Second change\"")
+      shas.push(s.rev_sha1("HEAD"))  
+    end
+    cut = RIM::UploadHelper.new(@ws_dir, true, @logger, [mod1_info])
+    cut.upload
+    module_session(mod1_info) do |s|
+      s.execute("git checkout --detach master")
+      s.execute("git branch -D master")
+    end
+    # reset testbr now on previous commit and commit new change
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git checkout -B testbr HEAD~2")
+      `echo 'Test' > #{File.join(@ws_dir, "mod1/test_file.txt")}`
+      s.execute("git add .")
+      s.execute("git commit . -m \"Third change\"")      
+    end
+    cut.upload
+    module_session(mod1_info) do |s|
+      s.execute("git checkout --detach master")
+      s.execute("git branch -D master")
+    end
+    # now merge the commits
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git merge #{shas[0]} --commit")
+    end
+    cut.upload
+    module_session(mod1_info) do |s|
+      s.execute("git checkout master")
+      assert File.exist?(File.join(@remote_git_dir, "mod1/readme.txt"))
+      assert File.exist?(File.join(@remote_git_dir, "mod1/new_file.txt"))
+      assert File.exist?(File.join(@remote_git_dir, "mod1/new_file2.txt"))
+      assert File.exist?(File.join(@remote_git_dir, "mod1/test_file.txt"))
+      assert s.execute("git show -s --format=%B HEAD").start_with?("Merge commit")
+      assert s.execute("git show -s --format=%B HEAD~1").start_with?("Third change")
+    end
+  end
+  
+private
+  def create_ws_git(branch = "master")
+    FileUtils.mkdir_p(@ws_remote_dir)
+    RIM::git_session(@ws_remote_dir) do |s|
+      s.execute("git init")
+      s.execute("git checkout -B #{branch}")
+      File.open(File.join(@ws_remote_dir, ".gitignore"), "w") do |f| 
+        f.write(".rim") 
+      end
+      File.open(File.join(@ws_remote_dir, "readme"), "w") do |f|
+        f.write("Content")
+      end
+      s.execute("git add .")
+      s.execute("git commit -m \"Initial commit\"")
+      s.execute("git checkout --detach #{branch}")
+    end
+    FileUtils.mkdir_p(@ws_dir)
+    RIM::git_session(@ws_dir) do |s|
+      s.execute("git clone #{@ws_remote_dir} #{@ws_dir}")
+    end
+  end
+
+  def create_module_git(name, branch = "master", remote_branch_format = nil)
+    git_dir = File.join(@remote_git_dir, name)
+    FileUtils.mkdir_p(git_dir)
+    RIM::git_session(git_dir) do |s|
+      s.execute("git init")
+      s.execute("git checkout -B #{branch}")
+      File.open(File.join(git_dir, "readme.txt"), "w") do |f| 
+        f.write("Content.") 
+      end
+      s.execute("git add .")
+      s.execute("git commit -m \"Initial commit\"")
+      s.execute("git checkout --detach #{branch}")
+    end
+    return RIM::ModuleInfo.new("file://" + git_dir, name, branch, nil, remote_branch_format)
+  end
+
+  def module_session(module_info)
+    RIM::git_session(module_info.remote_url.gsub(/^file:\/\//, "")) do |s|
+      yield s
+    end    
+  end
+
+  def check_not_dirty(session)
+    status = RIM::StatusBuilder.new.rev_status(session, "HEAD")
+    status.modules.each do |m|
+      assert !m.dirty?
+    end    
+  end
+  
+  def has_ancestor?(session, rev, ancestor)
+    rev = session.execute("git rev-list #{rev}").include?(session.rev_sha1(ancestor))
+  end
+  
+end