piston 1.4.0 → 2.0.1

data/test/unit/svn/revision/test_validation.rb

@@ -0,0 +1,50 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../test_helper")
+
+class Piston::Svn::TestSvnRevisionValidation < Piston::TestCase
+  def setup
+    super
+    @repository = mock("repository")
+    @repository.stubs(:url).returns("svn://svn.my-repos.com/projects/libcalc/trunk")
+  end
+  
+  def test_revision_is_invalid_unless_same_uuid
+    rev = new_revision("HEAD", Piston::Svn::UUID => "1234")
+    rev.expects(:svn).with(:info, "--revision", "HEAD", @repository.url).returns(INFO)
+    assert_raise Piston::Svn::Revision::UuidChanged do
+      rev.validate!
+    end
+  end
+
+  def test_revision_is_invalid_if_repository_location_does_not_exist_anymore
+    rev = new_revision("HEAD", Piston::Svn::UUID => "038cbeb6-2227-0410-91ec-8f9533625906")
+    rev.expects(:svn).with(:info, "--revision", "HEAD", @repository.url).returns("#{@repository.url}:  (Not a valid URL)")
+    assert_raise Piston::Svn::Revision::RepositoryMoved do
+      rev.validate!
+    end
+  end
+
+  def test_revision_is_valid_if_repository_is_present_and_same_uuid
+    rev = new_revision("HEAD", Piston::Svn::UUID => "038cbeb6-2227-0410-91ec-8f9533625906")
+    rev.expects(:svn).with(:info, "--revision", "HEAD", @repository.url).returns(INFO)
+    assert_nothing_raised do
+      rev.validate!
+    end
+  end
+
+  protected
+  def new_revision(rev, recalled_values={})
+    Piston::Svn::Revision.new(@repository, rev, recalled_values)
+  end
+  
+  INFO = <<EOF
+Path: project
+URL: svn://svn.my-repos.com/projects/libcalc/trunk
+Repository Root: svn://svn.my-repos.com/projects
+Repository UUID: 038cbeb6-2227-0410-91ec-8f9533625906
+Revision: 1234
+Node Kind: directory
+Last Changed Author: francois
+Last Changed Rev: 1232
+Last Changed Date: 2008-04-06 21:57:10 -0400 (Sun, 06 Apr 2008)
+EOF
+end

data/test/unit/svn/working_copy/test_copying.rb

@@ -0,0 +1,26 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../test_helper")
+
+class Piston::Svn::TestSvnWorkingCopyCopying < Piston::TestCase
+  def setup
+    super
+    @wcdir = mkpath("tmp/wc")
+    @wc = Piston::Svn::WorkingCopy.new(@wcdir)
+    @wc.stubs(:svn)
+    @wc.stubs(:svn).with(:info, anything).returns("a:b")
+  end
+
+  def test_copies_files
+    files = ["file.rb"]
+    files.expects(:copy_to).with("file.rb", @wcdir + files.first)
+    @wc.copy_from(files)
+  end
+
+  def test_ensures_directories_are_created
+    files = ["file/a.rb"]
+    @wcdir.expects(:+).with(files.first).returns(target = mock("target"))
+    target.expects(:dirname).returns(target)
+    target.expects(:mkdir)
+    files.expects(:copy_to).with("file/a.rb", target)
+    @wc.copy_from(files)
+  end
+end

data/test/unit/svn/working_copy/test_creation.rb

@@ -0,0 +1,16 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../test_helper")
+
+class Piston::Svn::TestSvnWorkingCopyCreation < Piston::TestCase
+  def setup
+    super
+    @wcdir = mkpath("tmp/wc")
+    @wc = Piston::Svn::WorkingCopy.new(@wcdir)
+    @wc.stubs(:svn)
+    @wc.stubs(:svn).with(:info, anything).returns("a:b")
+  end
+
+  def test_create_uses_svn_mkdir
+    @wc.expects(:svn).with(:mkdir, @wcdir)
+    @wc.create
+  end
+end

data/test/unit/svn/working_copy/test_existence.rb

@@ -0,0 +1,23 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../test_helper")
+
+class Piston::Svn::TestSvnWorkingCopyExistence < Piston::TestCase
+  def setup
+    super
+    @wcdir = Pathname.new(File.expand_path("tmp/wc"))
+    @wc = Piston::Svn::WorkingCopy.new(@wcdir)
+  end
+
+  def test_exist_false_when_dir_not_present
+    deny @wc.exist?
+  end
+
+  def test_exist_false_when_dir_present_but_not_an_svn_wc
+    @wcdir.mkpath
+    deny @wc.exist?
+  end
+
+  def test_exist_true_when_svn_working_copy_at_path
+    @wc.expects(:svn).with(:info, @wcdir).returns("Path: b")
+    assert @wc.exist?
+  end
+end 

data/test/unit/svn/working_copy/test_externals.rb

@@ -0,0 +1,56 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../test_helper")
+
+class Piston::Svn::TestWorkingCopyExternals < Piston::TestCase
+  def setup
+    super
+    @wcdir = mkpath("tmp/wc")
+    @wc = Piston::Svn::WorkingCopy.new(@wcdir)
+  end
+
+  def test_parse_empty_svn_externals
+    @wc.stubs(:svn).returns(EMPTY_EXTERNALS)
+    assert_equal({}, @wc.externals)
+  end
+
+  def test_parse_simple_externals
+    @wc.stubs(:svn).returns(SIMPLE_RAILS_EXTERNALS)
+    assert_equal({@wcdir + "vendor/rails" => {:revision => :head, :url => "http://dev.rubyonrails.org/svn/rails/trunk"}}, @wc.externals)
+  end
+
+  def test_parse_externals_with_revision
+    @wc.stubs(:svn).returns(VERSIONED_RAILS_EXTERNALS)
+    assert_equal({@wcdir + "vendor/rails" => {:revision => 8726, :url => "http://dev.rubyonrails.org/svn/rails/trunk"}}, @wc.externals)
+  end
+
+  def test_parse_externals_with_long_revision
+    @wc.stubs(:svn).returns(LONG_VERSION_RAILS_EXTERNALS)
+    assert_equal({@wcdir + "vendor/rails" => {:revision => 8726, :url => "http://dev.rubyonrails.org/svn/rails/trunk"}}, @wc.externals)
+  end
+
+  def test_remove_external_references_calls_svn_propdel
+    @wc.expects(:svn).with(:propdel, "svn:externals", @wcdir+"vendor")
+    @wc.remove_external_references(@wcdir+"vendor")
+  end
+
+  def test_remove_external_references_calls_svn_propdel_with_multiple_dirs
+    @wc.expects(:svn).with(:propdel, "svn:externals", @wcdir+"vendor", @wcdir+"vendor/plugins")
+    @wc.remove_external_references(@wcdir+"vendor", @wcdir+"vendor/plugins")
+  end
+
+  EMPTY_EXTERNALS = ""
+  SIMPLE_RAILS_EXTERNALS = <<EOF
+  Properties on 'vendor':
+    svn:externals : rails http://dev.rubyonrails.org/svn/rails/trunk
+
+EOF
+  VERSIONED_RAILS_EXTERNALS = <<EOF
+  Properties on 'vendor':
+    svn:externals : rails -r8726 http://dev.rubyonrails.org/svn/rails/trunk
+
+EOF
+  LONG_VERSION_RAILS_EXTERNALS = <<EOF
+  Properties on 'vendor':
+    svn:externals : rails --revision 8726 http://dev.rubyonrails.org/svn/rails/trunk
+
+EOF
+end

data/test/unit/svn/working_copy/test_finalization.rb

@@ -0,0 +1,17 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../test_helper")
+
+class Piston::Svn::TestSvnWorkingCopyFinalization < Piston::TestCase
+  def setup
+    super
+    @wcdir = mkpath("tmp/wc")
+    @wc = Piston::Svn::WorkingCopy.new(@wcdir)
+  end
+
+  def test_finalize_adds_all_top_level_entries_to_working_copy
+    File.open(@wcdir + "a.rb", "wb") {|f| f.write "Hello World!"}
+    File.open(@wcdir + "b.rb", "wb") {|f| f.write "Hello World!"}
+    @wc.expects(:svn).with(:add, (@wcdir + "a.rb").to_s)
+    @wc.expects(:svn).with(:add, (@wcdir + "b.rb").to_s)
+    @wc.finalize
+  end
+end

data/test/unit/svn/working_copy/test_guessing.rb

@@ -0,0 +1,18 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../test_helper")
+
+class Piston::Svn::TestSvnWorkingCopyGuessing < Piston::TestCase
+  def setup
+    super
+    @dir = mkpath("tmp/wc")
+  end
+
+  def test_does_svn_info_on_directory
+    Piston::Svn::WorkingCopy.expects(:svn).with(:info, @dir).returns("Path: xxx\n")
+    assert Piston::Svn::WorkingCopy.understands_dir?(@dir)
+  end
+
+  def test_denies_when_svn_not_available
+    Piston::Svn::WorkingCopy.expects(:svn).with(:info, @dir).raises(Piston::Svn::Client::BadCommand)
+    deny Piston::Svn::WorkingCopy.understands_dir?(@dir)
+  end
+end

data/test/unit/svn/working_copy/test_rememberance.rb

@@ -0,0 +1,26 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../test_helper")
+
+class Piston::Svn::TestSvnWorkingCopyRememberance < Piston::TestCase
+  def setup
+    super
+    @wcdir = mkpath("tmp/wc")
+    @wc = Piston::Svn::WorkingCopy.new(@wcdir)
+    @wc.stubs(:svn)
+    @wc.stubs(:svn).with(:info, anything).returns("a:b")
+  end
+
+  def teardown
+    @wcdir.rmtree rescue nil
+  end
+
+  def test_after_remember_adds_path_using_svn
+    @wc.expects(:svn).with(:info, :the_path).returns("a: (Not a versioned resource)\n")
+    @wc.expects(:svn).with(:add, :the_path)
+    @wc.after_remember(:the_path)
+  end
+
+  def test_after_remember_does_not_add_if_file_already_under_version_control
+    @wc.expects(:svn).with(:info, :the_path).returns("a: b\n")
+    @wc.after_remember(:the_path)
+  end
+end

data/test/unit/test_info.rb

@@ -0,0 +1,37 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../test_helper")
+
+class TestInfo < Piston::TestCase
+  def setup
+    super
+    @values = {"lock" => false}
+    @wcdir = "tmp/wcdir"
+    @wc = mock("WorkingCopy")
+    @wc.stubs(:validate!)
+  end
+  
+  def test_info
+    run_and_verify do
+      @wc.expects(:info)
+    end
+  end
+
+  def test_validates_working_copy_before_working
+    assert_raise(Piston::WorkingCopy::NotWorkingCopy) do
+      run_and_verify do
+        @wc.expects(:validate!).raises(Piston::WorkingCopy::NotWorkingCopy)
+      end
+    end
+  end
+
+  private
+  def run_and_verify
+    yield
+    info_command.run(@wcdir)
+  end
+
+  def info_command
+    Piston::WorkingCopy.expects(:guess).with(@wcdir).returns(@wc)
+    Piston::Commands::Info.new(:verbose => "verbose",
+                                     :quiet => "quiet", :force => "force")
+  end
+end

data/test/unit/test_lock_unlock.rb

@@ -0,0 +1,47 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../test_helper")
+
+class TestLockUnlock < Piston::TestCase
+  def setup
+    super
+    @values = {"lock" => false}
+    @wcdir = "tmp/wcdir"
+    @wc = mock("WorkingCopy")
+    @wc.stubs(:validate!)
+  end
+
+  def test_lock_working_copy
+    run_and_verify(true) do
+      @wc.expects(:recall).returns(@values)
+      @wc.expects(:finalize).returns(@values)
+      @wc.expects(:remember).with(@values.merge("lock" => true), @values["handler"]).returns(@values)
+    end
+  end
+
+  def test_unlock_working_copy
+    run_and_verify(false) do
+      @wc.expects(:recall).returns(@values)
+      @wc.expects(:finalize).returns(@values)
+      @wc.expects(:remember).with(@values.merge("lock" => false), @values["handler"]).returns(@values)
+    end
+  end
+
+  def test_validates_working_copy_before_working
+    assert_raise(Piston::WorkingCopy::NotWorkingCopy) do
+      run_and_verify do
+        @wc.expects(:validate!).raises(Piston::WorkingCopy::NotWorkingCopy)
+      end
+    end
+  end
+
+  private
+  def run_and_verify(lock=true)
+    yield
+    lock_unlock_command.run(lock)
+  end
+
+  def lock_unlock_command
+    Piston::WorkingCopy.expects(:guess).with(File.expand_path(@wcdir)).returns(@wc)
+    Piston::Commands::LockUnlock.new(:verbose => "verbose", :wcdir => @wcdir,
+                                     :quiet => "quiet", :force => "force")
+  end
+end

data/test/unit/test_repository.rb

@@ -0,0 +1,51 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../test_helper")
+
+class TestRepository < Piston::TestCase
+  def setup
+    super
+    Piston::Repository.send(:handlers).clear
+  end
+
+  def test_guess_asks_each_handler_in_turn
+    Piston::Repository.add_handler(handler = mock("handler"))
+    handler.expects(:understands_url?).with("http://a.repos.com/trunk").returns(false)
+    assert_raise Piston::Repository::UnhandledUrl do
+      Piston::Repository.guess("http://a.repos.com/trunk")
+    end
+  end
+
+  def test_guess_returns_first_handler_that_understands_the_url
+    url = "svn://a.repos.com/projects/libcalc/trunk"
+
+    handler = mock("handler")
+    handler.expects(:understands_url?).with(url).returns(true)
+    handler_instance = mock("handler_instance")
+    handler.expects(:new).with(url).returns(handler_instance)
+
+    Piston::Repository.add_handler handler
+    assert_equal handler_instance, Piston::Repository.guess(url)
+  end
+
+  def test_guess_raises_unhandled_url_exception_when_no_repository_handler_found
+    assert_raise(Piston::Repository::UnhandledUrl) do
+      Piston::Repository.guess("invalid")
+    end
+  end
+
+  def test_add_handler
+    Piston::Repository.add_handler(handler = mock("handler"))
+    assert_equal [handler], Piston::Repository.send(:handlers)
+  end
+
+  def test_initialize_stores_url_parameter_in_url_accessor
+    @repository = Piston::Repository.new("url")
+    assert_equal "url", @repository.url
+  end
+
+  def test_at_is_a_subclass_responsibility
+    @repository = Piston::Repository.new("url")
+    assert_raise(SubclassResponsibilityError) do
+      @repository.at(:any)
+    end
+  end
+end

data/test/unit/test_revision.rb

@@ -0,0 +1,31 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../test_helper")
+
+class TestRevision < Piston::TestCase
+  def setup
+    super
+    @repository = mock("repository")
+    @revision_number = "1"
+    @revision = Piston::Revision.new(@repository, @revision_number)
+  end
+
+  def test_initialize
+    assert_equal @repository, @revision.repository
+    assert_equal @revision_number, @revision.revision
+  end
+
+  def test_repository
+    assert_equal @repository, @revision.repository
+  end
+
+  def test_revision
+    assert_equal @revision_number, @revision.revision
+  end
+
+  def test_name
+    assert_equal @revision_number, @revision.name
+  end
+
+  def test_default_recalled_values_are_an_empty_hash
+    assert_equal Hash.new, @revision.recalled_values
+  end
+end

data/test/unit/working_copy/test_guessing.rb

@@ -0,0 +1,35 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../test_helper")
+
+class TestWorkingCopyGuessing < Piston::TestCase
+  def setup
+    super
+    Piston::WorkingCopy.send(:handlers).clear
+    @dir = mkpath("tmp/wc")
+  end
+
+  def test_guess_when_no_handlers_raises
+    assert_raise Piston::WorkingCopy::UnhandledWorkingCopy do
+      Piston::WorkingCopy.guess(@dir)
+    end
+  end
+
+  def test_guess_asks_each_handler_in_turn
+    Piston::WorkingCopy.add_handler(handler = mock("handler"))
+    handler.stubs(:name).returns("aname")
+    handler.expects(:understands_dir?).with(@dir).returns(false)
+    assert_raise Piston::WorkingCopy::UnhandledWorkingCopy do
+      Piston::WorkingCopy.guess(@dir)
+    end
+  end
+
+  def test_guess_returns_first_handler_that_understands_the_url
+    handler = mock("handler")
+    handler.stubs(:name).returns("aname")
+    handler.expects(:understands_dir?).with(@dir).returns(true)
+    handler_instance = mock("handler_instance")
+    handler.expects(:new).with(File.expand_path(@dir)).returns(handler_instance)
+
+    Piston::WorkingCopy.add_handler handler
+    assert_equal handler_instance, Piston::WorkingCopy.guess(@dir)
+  end
+end

data/test/unit/working_copy/test_info.rb

@@ -0,0 +1,14 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../test_helper")
+
+class TestWorkingCopyInfo < Piston::TestCase
+  def setup
+    super
+    @path = mkpath("tmp/wc")
+    @wc = Piston::WorkingCopy.new(@path)
+  end
+  
+  def test_info_recalls_values
+    @wc.expects(:recall).returns(values = mock("recalled values"))
+    assert_equal values, @wc.info
+  end
+end

data/test/unit/working_copy/test_rememberance.rb

@@ -0,0 +1,42 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../test_helper")
+
+class TestWorkingCopyRememberance < Piston::TestCase
+  def setup
+    super
+    @wcdir = mkpath("tmp/wc")
+    @wc = Piston::WorkingCopy.new(@wcdir)
+  end
+
+  def test_remember_generates_piston_yml_file_in_wc
+    @wc.remember({}, "a" => "b")
+    assert((@wcdir + ".piston.yml").exist?, "tmp/wc/.piston.yml file doesn't exist")
+  end
+
+  def test_writes_values_as_yaml_under_handler_key
+    expected = {"a" => "b"}
+    @wc.remember({}, expected)
+    actual = YAML.load_file(@wcdir + ".piston.yml")
+    assert_equal expected, actual["handler"]
+  end
+
+  def test_remember_calls_after_remember_with_path_to_piston_yml_file
+    @wc.expects(:after_remember).with(Pathname.new(@wcdir + ".piston.yml"))
+    @wc.remember({}, "a" => "b")
+  end
+
+  def test_remember_with_two_args_remembers_handler_values_separately
+    values = {"lock" => true}
+    handler_values = {"a" => "b"}
+
+    @wc.remember(values, handler_values)
+
+    actual = YAML.load_file(@wcdir + ".piston.yml")
+    assert_equal values.merge("format" => 1, "handler" => handler_values), actual
+  end
+
+  def test_recall_returns_hash_of_values
+    values = {"a" => "b", "handler" => {"b" => "c"}}
+    YAML.expects(:load_file).with(@wcdir + ".piston.yml").returns(values)
+    assert_equal values, @wc.recall
+  end
+end

data/test/unit/working_copy/test_validate.rb

@@ -0,0 +1,63 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../test_helper")
+
+class TestWorkingCopyValidate < Piston::TestCase
+  def setup
+    super
+    @wcdir = mkpath("tmp/wc")
+    @wc = Piston::WorkingCopy.new(@wcdir)
+  end
+
+  def test_exists_when_the_directory_exists
+    assert @wc.exist?, "WorkingCopy should have existed, since the directory exists"
+  end
+
+  def test_does_not_exist_when_directory_not_present
+    @wcdir.rmtree
+    deny @wc.exist?, "WorkingCopy should NOT have existed, since the directory does not exist"
+  end
+
+  def test_does_not_exist_when_directory_is_a_file
+    @wcdir.rmtree
+    touch(@wcdir)
+    deny @wc.exist?, "WorkingCopy should NOT have existed, since the directory is a file"
+  end
+  
+  def test_is_pistonized_if_exist_and_has_piston_dot_yaml_file
+    @wc.stubs(:exist?).returns(true)
+    touch(@wcdir + ".piston.yml")
+    assert @wc.pistonized?, "WorkingCopy should be Pistonized, since the .piston.yml file exists"
+  end
+
+  def test_is_NOT_pistonized_if_no_piston_dot_yaml_file
+    @wc.stubs(:exist?).returns(true)
+    deny @wc.pistonized?, "WorkingCopy should not be Pistonized, since the .piston.yml does not file exists"
+  end
+
+  def test_is_NOT_pistonized_if_exist_returns_false
+    @wc.stubs(:exist?).returns(false)
+    deny @wc.pistonized?, "WorkingCopy should not be Pistonized, since #exist? returned false"
+  end
+
+  def test_is_NOT_pistonized_if_piston_dot_yaml_is_a_directory
+    @wc.stubs(:exist?).returns(true)
+    (@wcdir + ".piston.yml").mkdir
+    deny @wc.pistonized?, "WorkingCopy should not be Pistonized, since .piston.yml is a directory"
+  end
+
+  def test_validate_bang_returns_self_when_ok
+    @wc.stubs(:pistonized?).returns(true)
+    assert_equal @wc, @wc.validate!
+  end
+
+  def test_validate_bang_raises_not_working_copy_when_not_pistonized
+    @wc.stubs(:pistonized?).returns(false)
+    assert_raise(Piston::WorkingCopy::NotWorkingCopy) do
+      @wc.validate!
+    end
+  end
+
+  protected
+  def touch(path)
+    File.open(path, "wb") {|f| f.write ""}
+  end
+end