rscm 0.2.1.1404 → 0.3.0

data/lib/rscm/time_ext.rb

@@ -1,125 +1,11 @@
-module RSCM
-  module TimeExt
-    SECOND =   1
-    MINUTE =  60
-    HOUR   =  60 * MINUTE
-    DAY    =  24 * HOUR
-    WEEK   =   7 * DAY
-    MONTH  =  30 * DAY
-    YEAR   = 365 * DAY
-    YEARS  =   2 * YEAR
-
-    def duration_as_text(duration_secs)
-      case duration_secs
-        when 0                   then "0 seconds"
-        when SECOND              then "#{duration_secs/SECOND} second"
-        when SECOND+1..MINUTE-1  then "#{duration_secs/SECOND} seconds"
-        when MINUTE..2*MINUTE-1  then "#{duration_secs/MINUTE} minute"
-        when 2*MINUTE..HOUR-1    then "#{duration_secs/MINUTE} minutes"
-        when HOUR..2*HOUR-1      then "#{duration_secs/HOUR} hour"
-        when 2*HOUR..DAY-1       then "#{duration_secs/HOUR} hours"
-        when DAY..2*DAY-1        then "#{duration_secs/DAY} day"
-        when 2*DAY..WEEK-1       then "#{duration_secs/DAY} days"
-        when WEEK..2*WEEK-1      then "#{duration_secs/WEEK} week"
-        when 2*WEEK..MONTH-1     then "#{duration_secs/WEEK} weeks"
-        when MONTH..2*MONTH-1    then "#{duration_secs/MONTH} month"
-        when 2*MONTH..YEAR-1     then "#{duration_secs/MONTH} months"
-        when YEAR..2*YEAR-1      then "#{duration_secs/YEAR} year"
-        else                          "#{duration_secs/YEAR} years"
-      end
-    end
-    module_function :duration_as_text
-  end
-end
-
-# Time mixin that adds some additional utility methods
 class Time
-  include RSCM::TimeExt
-
   class << self
     def epoch
-      Time.utc(1970)
+      Time.utc(1972)
     end
 
     def infinity
-      Time.utc(2038)
-    end
-  end
-  
-  def Time.parse_ymdHMS(timestamp_as_ymdHMS)
-    Time.utc(
-      timestamp_as_ymdHMS[0..3], # year 
-      timestamp_as_ymdHMS[4..5], # month
-      timestamp_as_ymdHMS[6..7], # day
-      timestamp_as_ymdHMS[8..9], # hour
-      timestamp_as_ymdHMS[10..11], # minute
-      timestamp_as_ymdHMS[12..13] # second
-    )
-  end
-  
-  def to_rfc2822
-    utc.strftime("%a, %d %b %Y %H:%M:%S +0000")
-  end
-  
-  def to_human
-    utc.strftime("%d %b %Y %H:%M:%S")
-  end
-  
-  def ymdHMS
-    utc.strftime("%Y%m%d%H%M%S")
-  end
-  
-  def ==(o)
-    return false unless o.is_a?(Time)
-    ymdHMS == o.ymdHMS
-  end
-
-  # In many cases (for example when drawing a graph with 
-  # dates along the x-axis) it can be useful to know what
-  # month, week or day a certain timestamp is within.
-  #
-  # This lets you do that. Call with :day, :week or :month
-  # returns period_number, period_start
-  #
-  # period_number is an int representing the day, week or month number of the year.
-  # period_start is a utc time of the start of the period.
-  def get_period_info(interval)
-    case interval
-      when :week then get_week_info
-      when :month then get_month_info
-      when :day then get_day_info
+      Time.utc(2036)
     end
   end
-
-  # week_number, week_start_date = get_info(time, :week)
-  def get_week_info
-    first_day_of_year = Time.utc(utc.year, 1, 1)
-    week_day_of_first_day_of_year = first_day_of_year.wday
-    # Sunday = 0, .. Monday = 6
-    first_monday_of_year = Time.utc(utc.year, 1, ((week_day_of_first_day_of_year % 7) + 1))
-
-    week_number = nil
-    week_start_date = nil
-    days = (utc.yday - first_monday_of_year.yday)
-    week_number = (days / 7) + 1
-    week_start_date = first_monday_of_year + ((week_number-1) * 7) * 60 * 60 * 24
-    return week_number, week_start_date
-  end
-
-  # month_number, month_start_date = get_info(time, :month)
-  def get_month_info
-    return month, Time.utc(utc.year, utc.month, 1)
-  end
-
-  # day_number, day_date = get_info(time, :day)
-  def get_day_info
-    return yday, Time.utc(utc.year, utc.month, utc.day)
-  end
-
-  def difference_as_text(t)
-    raise "t must be a time" unless t.is_a?(Time)
-    diff = (self - t).to_i
-    duration_as_text(diff)
-  end
-
 end

data/test/rscm/annotations_test.rb

@@ -4,16 +4,18 @@ require 'rscm/annotations'
 module RSCM
   class Whatever
     attr_accessor :no_annotation
+
     ann :boo => "huba luba", :pip => "pip pip"
     attr_accessor :foo
   
     ann :desc => "bang bang"
     ann :tip => "a top tip"
-    attr_accessor :bar, :zap
+    attr_accessor :bar, :zap, :titi
   end
 
   class Other
     attr_accessor :no_annotation
+
     ann :boo => "boo"
     ann :pip => "pip"
     attr_accessor :foo
@@ -23,6 +25,8 @@ module RSCM
   end
   
   class Subclass < Other
+    ann :desc => "desc", :tip => "tip"
+    attr_accessor :other
   end
 
   class AnnotationsTest < Test::Unit::TestCase
@@ -51,7 +55,16 @@ module RSCM
     def test_should_inherit_attribute_annotations
       assert_equal("boo", Subclass.foo[:boo])
       assert_equal({:boo => "boo", :pip => "pip"}, Subclass.send("foo"))
-      assert_nil(Whatever.send("no_annotation"))
+      assert_equal({}, Whatever.send("no_annotation"))
+    end
+    
+    def test_should_get_annotations_from_object
+      assert_equal({:boo => "huba luba", :pip => "pip pip"}, Whatever.new.anns("foo"))
+    end
+    
+    def test_should_get_annotations_from_class
+      assert_equal(["@bar", "@foo", "@no_annotation", "@other", "@zap"], Subclass.new.__attr_accessors)
     end
+    
   end
 end

data/test/rscm/{abstract_scm_test.rb → base_test.rb}

@@ -6,11 +6,11 @@ module RSCM
     def test_should_load_all_scm_classes
       expected_scms_classes = [
         Cvs,
-        Darcs,
+#        Darcs,
         Monotone,
-        Mooky,
+#        Mooky,
         Perforce,
-        StarTeam,
+#        StarTeam,
         Subversion
       ]
       assert_equal(

data/test/rscm/difftool_test.rb

@@ -8,6 +8,13 @@ module Test
       # assertion method that reports differences as diff.
       # useful when comparing big strings
       def assert_equal_with_diff(expected, actual)
+        diff(expected, actual) do |diff_io|
+          diff_string = diff_io.read
+          assert_equal("", diff_string, diff_string)
+        end
+      end
+      
+      def diff(expected, actual, &block)
         dir = RSCM.new_temp_dir("diff")
         
         expected_file = "#{dir}/expected"
@@ -17,8 +24,7 @@ module Test
 
         difftool = WINDOWS ? File.dirname(__FILE__) + "/../../bin/diff.exe" : "diff"
         IO.popen("#{difftool} #{RSCM::PathConverter.filepath_to_nativepath(expected_file, false)} #{RSCM::PathConverter.filepath_to_nativepath(actual_file, false)}") do |io|
-          diff = io.read
-          assert_equal("", diff, diff)
+          yield io
         end
       end
     end
@@ -26,7 +32,7 @@ module Test
 end
 
 module RSCM
-  class DiffPersisterTest < Test::Unit::TestCase
+  class DifftoolTest < Test::Unit::TestCase
     def test_diffing_fails_with_diff_when_different
       assert_raises(Test::Unit::AssertionFailedError) {
         assert_equal_with_diff("This is a\nmessage with\nsome text", "This is a\nmessage without\nsome text")

data/test/rscm/generic_scm_tests.rb

@@ -1,51 +1,69 @@
 require 'fileutils'
 require 'rscm/tempdir'
 require 'rscm/path_converter'
+require 'rscm/difftool_test'
 
 module RSCM
 
   module GenericSCMTests
     include FileUtils
 
-    # Acceptance test for scm implementations 
+    def teardown
+      @scm.destroy_central if @scm
+    end
+
+    #  Acceptance test for scm implementations 
     #
-    #  1) Create a repo
-    #  2) Import a test project
-    #  3) Verify that CheckoutHere is not uptodate
-    #  4) Check out to CheckoutHere
+    #  1) Create a central repository
+    #  2) Import a test project to the central repository
+    #  3) Verify that WorkingCopy is not uptodate (not yet checked out)
+    #  4) Check out the contents of the central repo to WorkingCopy
     #  5) Verify that the checked out files were those imported
-    #  6) Verify that the initial total changesets (from epoch to infinity) represents those from the import
-    #  7) Verify that CheckoutHere is uptodate
-    #  8) Change some files in DeveloperOne's working copy
-    #  9) Check out to CheckoutHereToo
-    # 10) Verify that CheckoutHereToo is uptodate
-    # 11) Verify that CheckoutHere is uptodate
-    # 12) Commit modifications in CheckoutHere is uptodate
-    # 13) Verify that CheckoutHere is uptodate
-    # 14) Verify that CheckoutHereToo is not uptodate
-    # 15) Check out to CheckoutHereToo
-    # 16) Verify that CheckoutHereToo is uptodate
-    # 17) Add and commit a file in CheckoutHere
-    # 18) Verify that the changeset (since last changeset) for CheckoutHereToo contains only one file
+    #  6) Verify that the initial total revisions (from epoch to infinity) represents those from the import
+    #  7) Verify that WorkingCopy is uptodate
+    #  8) Change some files in WorkingCopy without committing them (yet)
+    #  9) Check out the contents of the central repo to OtherWorkingCopy
+    # 10) Verify that OtherWorkingCopy is uptodate
+    # 11) Verify that WorkingCopy is uptodate
+    # 12) Commit modifications in WorkingCopy
+    # 13) Verify that there is one revision since the previous one, and that it corresponds to the changed files in 8.
+    # 14) Verify that OtherWorkingCopy is *not* uptodate
+    # 15) Check out OtherWorkingCopy
+    # 16) Verify that OtherWorkingCopy is now uptodate
+    # 17) Add and commit a file in WorkingCopy
+    # 18) Verify that the revision (since last revision) for CheckoutHereToo contains only one file
     def test_basics
       work_dir = RSCM.new_temp_dir("basics")
-      checkout_dir = "#{work_dir}/CheckoutHere"
-      other_checkout_dir = "#{work_dir}/CheckoutHereToo"
+      checkout_dir = "#{work_dir}/WorkingCopy"
+      other_checkout_dir = "#{work_dir}/OtherWorkingCopy"
       repository_dir = "#{work_dir}/repository"
-      scm = create_scm(repository_dir, "damagecontrolled") 
-      scm.create
+      scm = create_scm(repository_dir, "damagecontrolled")
+      scm.checkout_dir = checkout_dir
+
+      other_scm = create_scm(repository_dir, "damagecontrolled")
+      other_scm.checkout_dir = other_checkout_dir
+
+      raise "This scm (#{scm.name}) can't create 'central' repositories." unless scm.can_create_central?
+
+      # 1
+      scm.create_central
+      @scm = scm
       assert(scm.name)
 
+      # 2
       import_damagecontrolled(scm, "#{work_dir}/damagecontrolled")
-
-      # test twice - to verify that uptodate? doesn't check out.      
-      assert(!scm.uptodate?(checkout_dir, Time.new.utc))
-      assert(!scm.uptodate?(checkout_dir, Time.new.utc))
+      
+      # 3
+      assert(!scm.uptodate?(nil))
+      assert(!scm.uptodate?(nil))
+      
+      # 4
       yielded_files = []
-      files = scm.checkout(checkout_dir) do |file_name|
+      files = scm.checkout do |file_name|
         yielded_files << file_name
       end
-
+      
+      # 5
       assert_equal(4, files.length)
       assert_equal(files, yielded_files)
       files.sort!
@@ -57,102 +75,141 @@ module RSCM
       assert_equal("src/java/com/thoughtworks/damagecontrolled/Thingy.java", files[2])
       assert_equal("src/test/com/thoughtworks/damagecontrolled/ThingyTestCase.java", files[3])
 
-      initial_changesets = scm.changesets(checkout_dir, nil, nil)
-      assert_equal(1, initial_changesets.length)
-      initial_changeset = initial_changesets[0]
-      assert_equal("imported\nsources", initial_changeset.message)
-      assert_equal(4, initial_changeset.length)
-      assert(scm.uptodate?(checkout_dir, initial_changesets.latest.time + 1))
+      # 6
+      initial_revisions = scm.revisions(nil, nil)
+      assert_equal(1, initial_revisions.length)
+      initial_revision = initial_revisions[0]
+      assert_equal("imported\nsources", initial_revision.message)
+      assert_equal(4, initial_revision.length)
+
+      # 7
+      assert(scm.uptodate?(initial_revisions.latest.identifier))
 
-      # modify file and commit it
+      # 8
       change_file(scm, "#{checkout_dir}/build.xml")
       change_file(scm, "#{checkout_dir}/src/java/com/thoughtworks/damagecontrolled/Thingy.java")
 
-      scm.checkout(other_checkout_dir)
-      assert(scm.uptodate?(other_checkout_dir, Time.new.utc))
-      assert(scm.uptodate?(checkout_dir, Time.new.utc))
+      # 9
+      other_scm.checkout
+      # 10
+      assert(other_scm.uptodate?(nil))
+      # 11
+      assert(scm.uptodate?(nil))
+      # 12
+      scm.commit("changed\nsomething") 
 
-      scm.commit(checkout_dir, "changed\nsomething") 
+      # 13
+      revisions = scm.revisions(initial_revisions.latest.identifier)
+      assert(revisions[0].identifier)
+      assert_equal(1, revisions.length, revisions.collect{|cs| cs.to_s})
+      revision = revisions[0]
+      assert_equal(2, revision.length)
 
-      # check that we now have one more change
-      changesets = scm.changesets(checkout_dir, initial_changesets.time + 1)
-
-      assert_equal(1, changesets.length, changesets.collect{|cs| cs.to_s})
-      changeset = changesets[0]
-      assert_equal(2, changeset.length)
-
-      assert_equal("changed\nsomething", changeset.message)
+      assert_equal("changed\nsomething", revision.message)
 
       # why is this nil when running as the dcontrol user on codehaus? --jon
-      #assert_equal(username, changeset.developer)
-      assert(changeset.developer)
-      assert(changeset.identifier)
-
-      assert_equal("build.xml", changeset[0].path)
-      assert(changeset[0].revision)
-      assert(changeset[0].previous_revision)
-      assert_equal("src/java/com/thoughtworks/damagecontrolled/Thingy.java", changeset[1].path)
-      assert(changeset[1].revision)
-      assert(changeset[1].previous_revision)      
-
-      assert(!scm.uptodate?(other_checkout_dir, changesets.latest.time+1))
-      assert(!scm.uptodate?(other_checkout_dir, changesets.latest.time+1))
-      assert(scm.uptodate?(checkout_dir, changesets.latest.time+1))
-      assert(scm.uptodate?(checkout_dir, changesets.latest.time+1))
-
-      files = scm.checkout(other_checkout_dir).sort
+      #assert_equal(username, revision.developer)
+      assert(revision.developer)
+      assert(revision.identifier)
+
+      assert_equal("build.xml", revision[0].path)
+      assert(revision[0].native_revision_identifier)
+      assert(revision[0].previous_native_revision_identifier)
+      assert_equal("src/java/com/thoughtworks/damagecontrolled/Thingy.java", revision[1].path)
+      assert(revision[1].native_revision_identifier)
+      assert(revision[1].previous_native_revision_identifier)      
+
+      # 14
+      assert(!other_scm.uptodate?(revisions.latest.identifier))
+      assert(!other_scm.uptodate?(revisions.latest.identifier))
+      assert(scm.uptodate?(revisions.latest.identifier))
+      assert(scm.uptodate?(revisions.latest.identifier))
+
+      # 15
+      files = other_scm.checkout.sort
       assert_equal(2, files.length)
       assert_equal("build.xml", files[0])
       assert_equal("src/java/com/thoughtworks/damagecontrolled/Thingy.java", files[1])
 
-      assert(scm.uptodate?(other_checkout_dir, Time.new.utc))
-
+      # 16
+      assert(other_scm.uptodate?(nil))
       add_or_edit_and_commit_file(scm, checkout_dir, "src/java/com/thoughtworks/damagecontrolled/Hello.txt", "Bla bla")
-      assert(!scm.uptodate?(other_checkout_dir, Time.new.utc))
-      changesets = scm.changesets(other_checkout_dir, changesets.time + 1)
-      assert_equal(1, changesets.length)
-      assert_equal(1, changesets[0].length)
-      assert("src/java/com/thoughtworks/damagecontrolled/Hello.txt", changesets[0][0].path)
-      assert("src/java/com/thoughtworks/damagecontrolled/Hello.txt", scm.checkout(other_checkout_dir).sort[0])
+      assert(!other_scm.uptodate?(nil))
+      revisions = other_scm.revisions(revisions.latest.identifier)
+      assert_equal(1, revisions.length)
+      assert_equal(1, revisions[0].length)
+      assert("src/java/com/thoughtworks/damagecontrolled/Hello.txt", revisions[0][0].path)
+      assert("src/java/com/thoughtworks/damagecontrolled/Hello.txt", other_scm.checkout.sort[0])
+    end
+
+    def test_create_destroy
+      work_dir = RSCM.new_temp_dir("create_destroy")
+      checkout_dir = "#{work_dir}/checkout"
+      repository_dir = "#{work_dir}/repository"
+      scm = create_scm(repository_dir, "killme")
+      scm.checkout_dir = checkout_dir
+
+      (1..3).each do
+        assert(!scm.central_exists?)
+        scm.create_central
+        assert(scm.central_exists?)
+        scm.destroy_central
+      end
+
+      assert(!scm.central_exists?)
     end
     
     def test_trigger
       work_dir = RSCM.new_temp_dir("trigger")
-      path = "OftenModified"
-      checkout_dir = "#{work_dir}/#{path}/checkout"
+      checkout_dir = "#{work_dir}/checkout"
       repository_dir = "#{work_dir}/repository"
-      scm = create_scm(repository_dir, path)
-      scm.create 
+      trigger_proof = "#{work_dir}/trigger_proof"
+      scm = create_scm(repository_dir, "damagecontrolled")
+      scm.checkout_dir = checkout_dir
+      scm.create_central 
+      @scm = scm
       
+      # Verify that install/uninstall works
+      touch = WINDOWS ? PathConverter.filepath_to_nativepath(File.dirname(__FILE__) + "../../bin/touch.exe", false) : "touch"
+      trigger_command = "#{touch} " + PathConverter.filepath_to_nativepath(trigger_proof, false)
       trigger_files_checkout_dir = File.expand_path("#{checkout_dir}/../trigger")
-      trigger_command = "bla bla"
-      (1..3).each do
+      (1..3).each do |i|
         assert(!scm.trigger_installed?(trigger_command, trigger_files_checkout_dir))
         scm.install_trigger(trigger_command, trigger_files_checkout_dir)
         assert(scm.trigger_installed?(trigger_command, trigger_files_checkout_dir))
         scm.uninstall_trigger(trigger_command, trigger_files_checkout_dir)
       end
+
+      # Verify that the trigger works
+      import_damagecontrolled(scm, "#{work_dir}/damagecontrolled")
+      scm.checkout
+      scm.install_trigger(trigger_command, trigger_files_checkout_dir)
+      assert(!File.exist?(trigger_proof))
+
+      add_or_edit_and_commit_file(scm, checkout_dir, "afile", "boo")
+      assert(File.exist?(trigger_proof))
     end
 
-    def test_checkout_changeset_identifier
-      work_dir = RSCM.new_temp_dir("label")
+    def test_checkout_revision_identifier
+      work_dir = RSCM.new_temp_dir("ids")
       checkout_dir = "#{work_dir}/checkout"
       repository_dir = "#{work_dir}/repository"
       scm = create_scm(repository_dir, "damagecontrolled")
-      scm.create
+      scm.checkout_dir = checkout_dir
+      scm.create_central
+      @scm = scm
 
       import_damagecontrolled(scm, "#{work_dir}/damagecontrolled")
-      scm.checkout(checkout_dir)
+      scm.checkout
       add_or_edit_and_commit_file(scm, checkout_dir, "before.txt", "Before label")
-      before_cs = scm.changesets(checkout_dir, Time.epoch)
+      before_cs = scm.revisions(Time.epoch)
 
       add_or_edit_and_commit_file(scm, checkout_dir, "after.txt", "After label")
-      next_identifier = before_cs.latest.identifier + 1
-      after_cs = scm.changesets(checkout_dir, next_identifier)
+      after_cs = scm.revisions(before_cs.latest.identifier)
       assert_equal(1, after_cs.length)
       assert_equal("after.txt", after_cs[0][0].path)
 
-      scm.checkout(checkout_dir, before_cs.latest.identifier)
+      scm.checkout(before_cs.latest.identifier)
 
       assert(File.exist?("#{checkout_dir}/before.txt"))
       assert(!File.exist?("#{checkout_dir}/after.txt"))
@@ -164,51 +221,63 @@ module RSCM
       assert_same(scm.class, scm2.class)
     end
 
-    def test_diff
+    EXPECTED_DIFF = <<EOF
+-one two three
+-four five six
++one two three four
++five six
+EOF
+    
+    def test_diffs
       work_dir = RSCM.new_temp_dir("diff")
-      path = "diffing"
-      checkout_dir = "#{work_dir}/#{path}/checkout"
+      checkout_dir = "#{work_dir}/checkout"
       repository_dir = "#{work_dir}/repository"
       import_dir = "#{work_dir}/import/diffing"
-      scm = create_scm(repository_dir, path)
-      scm.create
+      scm = create_scm(repository_dir, "diffing")
+      scm.checkout_dir = checkout_dir
+      scm.create_central
+      @scm = scm
       
       mkdir_p(import_dir)
       File.open("#{import_dir}/afile.txt", "w") do |io|
+        io.puts("just some")
+        io.puts("initial content")
+      end      
+      scm.import_central(import_dir, "Initial revision")
+      scm.checkout
+      initial_revision = scm.revisions(nil).latest
+      sleep(1)
+
+      scm.edit("#{checkout_dir}/afile.txt")
+      File.open("#{checkout_dir}/afile.txt", "w") do |io|
         io.puts("one two three")
         io.puts("four five six")
       end
-      File.open("#{import_dir}/afile.txt", "w") do |io|
-        io.puts("")
-      end
-      
-      scm.import(import_dir, "Imported a file to diff against")
-      scm.checkout(checkout_dir)
+      scm.commit("Modified existing file")
+      sleep(1)
 
       scm.edit("#{checkout_dir}/afile.txt")
       File.open("#{checkout_dir}/afile.txt", "w") do |io|
         io.puts("one two three four")
         io.puts("five six")
       end
-      File.open("#{checkout_dir}/anotherfile.txt", "w") do |io|
-        io.puts("one quick brown")
-        io.puts("fox jumped over")
-      end
-      scm.commit(checkout_dir, "Modified file to diff")
+      scm.commit("Modified same file again")
 
-      scm.edit("#{checkout_dir}/afile.txt")
-      File.open("#{checkout_dir}/afile.txt", "w") do |io|
-        io.puts("one to threee")
-        io.puts("hello")
-        io.puts("four five six")
-      end
-      File.open("#{checkout_dir}/anotherfile.txt", "w") do |io|
-        io.puts("one quick brown")
-        io.puts("fox jumped over the lazy dog")
-      end
-      scm.commit(checkout_dir, "Modified file to diff again")
+      revisions = scm.revisions(initial_revision.identifier)
+      assert_equal(2, revisions.length)
+      assert_equal("Modified existing file", revisions[0].message)
+      assert_equal("Modified same file again", revisions[1].message)
       
-      changesets = scm.changesets(checkout_dir, Time.epoch)
+      got_diff = false
+      scm.diff(revisions[1][0]) do |diff_io|
+        got_diff = true
+        diff_string = diff_io.read
+        assert_match(/^\-one two three/, diff_string)
+        assert_match(/^\-four five six/, diff_string)
+        assert_match(/^\+one two three four/, diff_string)
+        assert_match(/^\+five six/, diff_string)
+      end
+      assert(got_diff)
     end
 
   private
@@ -221,7 +290,7 @@ module RSCM
       cp_r(path, dirname)
       todelete = Dir.glob("#{import_copy_dir}/**/.svn")
       rm_rf(todelete)
-      scm.import(import_copy_dir, "imported\nsources")
+      scm.import_central(import_copy_dir, "imported\nsources")
     end
     
     def change_file(scm, file)
@@ -240,12 +309,12 @@ module RSCM
       File.open(absolute_path, "w") do |file|
         file.puts(content)
       end
-      scm.add(checkout_dir, relative_filename) unless(existed)
+      scm.add(relative_filename) unless existed
 
       message = existed ? "editing" : "adding"
 
       sleep(1)
-      scm.commit(checkout_dir, "#{message} #{relative_filename}")
+      scm.commit("#{message} #{relative_filename}")
     end
   end
     
@@ -255,23 +324,25 @@ module RSCM
       checkout_dir = "#{work_dir}/LabelTest"
       repository_dir = "#{work_dir}/repository"
       scm = create_scm(repository_dir, "damagecontrolled")
-      scm.create
+      scm.checkout_dir = checkout_dir
+      scm.create_central
+      @scm = scm
 
       import_damagecontrolled(scm, "#{work_dir}/damagecontrolled")
 
-      scm.checkout(checkout_dir)
+      scm.checkout
 
       # TODO: introduce a Revision class which implements comparator methods
       assert_equal(
         "1",
-        scm.label(checkout_dir) 
+        scm.label 
       )
       change_file(scm, "#{checkout_dir}/build.xml")
-      scm.commit(checkout_dir, "changed something")
-      scm.checkout(checkout_dir) 
+      scm.commit("changed something")
+      scm.checkout 
       assert_equal(
         "2",
-        scm.label(checkout_dir) 
+        scm.label 
       )
     end
   end
@@ -279,4 +350,4 @@ module RSCM
   module ApplyLabelTest
 
   end
-end
+end