minestrone 0.0.1

data/test/configuration/loading_test.rb

@@ -0,0 +1,149 @@
+require 'utils'
+require 'minestrone/configuration/loading'
+
+class ConfigurationLoadingTest < Test::Unit::TestCase
+  class MockConfig
+    attr_accessor :ping
+    attr_reader :original_initialize_called
+
+    def initialize
+      @original_initialize_called = true
+      initialize_loading
+    end
+
+    def ping!(value)
+      @ping = value
+    end
+
+    include Minestrone::Configuration::Loading
+  end
+
+  def setup
+    @config = MockConfig.new
+  end
+
+  def teardown
+    MockConfig.instance = nil
+    $LOADED_FEATURES.delete_if { |a| a =~ /fixtures\/custom\.rb$/ }
+  end
+
+  def test_initialize_should_init_collections
+    assert @config.original_initialize_called
+    assert @config.load_paths.include?(".")
+    assert @config.load_paths.detect { |v| v =~ /minestrone\/recipes$/ }
+  end
+
+  def test_load_with_options_and_block_should_raise_argument_error
+    assert_raises(ArgumentError) do
+      @config.load(:string => "foo") { something }
+    end
+  end
+
+  def test_load_with_arguments_and_block_should_raise_argument_error
+    assert_raises(ArgumentError) do
+      @config.load("foo") { something }
+    end
+  end
+
+  def test_load_from_string_should_eval_in_config_scope
+    @config.load :string => "ping! :here"
+    assert_equal :here, @config.ping
+  end
+
+  def test_load_from_file_shoudld_respect_load_path
+    File.stubs(:file?).returns(false)
+    File.stubs(:file?).with("custom/path/for/file.rb").returns(true)
+    File.stubs(:read).with("custom/path/for/file.rb").returns("ping! :here")
+
+    @config.load_paths << "custom/path/for"
+    @config.load :file => "file.rb"
+
+    assert_equal :here, @config.ping
+  end
+
+  def test_load_from_file_should_respect_load_path_and_appends_rb
+    File.stubs(:file?).returns(false)
+    File.stubs(:file?).with("custom/path/for/file.rb").returns(true)
+    File.stubs(:read).with("custom/path/for/file.rb").returns("ping! :here")
+
+    @config.load_paths << "custom/path/for"
+    @config.load :file => "file"
+
+    assert_equal :here, @config.ping
+  end
+
+  def test_load_from_file_should_raise_load_error_if_file_cannot_be_found
+    File.stubs(:file?).returns(false)
+    assert_raises(LoadError) do
+      @config.load :file => "file"
+    end
+  end
+
+  def test_load_from_proc_should_eval_proc_in_config_scope
+    @config.load :proc => Proc.new { ping! :here }
+    assert_equal :here, @config.ping
+  end
+
+  def test_load_with_block_should_treat_block_as_proc_parameter
+    @config.load { ping! :here }
+    assert_equal :here, @config.ping
+  end
+
+  def test_load_with_unrecognized_option_should_raise_argument_error
+    assert_raises(ArgumentError) do
+      @config.load :url => "http://www.load-this.test"
+    end
+  end
+
+  def test_load_with_arguments_should_treat_arguments_as_files
+    File.stubs(:file?).returns(false)
+    File.stubs(:file?).with("./first.rb").returns(true)
+    File.stubs(:file?).with("./second.rb").returns(true)
+    File.stubs(:read).with("./first.rb").returns("ping! 'this'")
+    File.stubs(:read).with("./second.rb").returns("ping << 'that'")
+    assert_nothing_raised { @config.load "first", "second" }
+    assert_equal "thisthat", @config.ping
+  end
+
+  def test_require_from_config_should_load_file_in_config_scope
+    assert_nothing_raised do
+      @config.require "#{File.expand_path(File.dirname(__FILE__))}/../fixtures/custom"
+    end
+    assert_equal :custom, @config.ping
+  end
+
+  def test_require_without_config_should_raise_load_error
+    assert_raises(LoadError) do
+      require "#{File.dirname(__FILE__)}/../fixtures/custom"
+    end
+  end
+
+  def test_require_from_config_should_return_false_when_called_a_second_time_with_same_args
+    assert @config.require("#{File.expand_path(File.dirname(__FILE__))}/../fixtures/custom")
+    assert_equal false, @config.require("#{File.expand_path(File.dirname(__FILE__))}/../fixtures/custom")
+  end
+
+  def test_require_in_multiple_instances_should_load_recipes_in_each_instance
+    config2 = MockConfig.new
+    @config.require "#{File.expand_path(File.dirname(__FILE__))}/../fixtures/custom"
+    config2.require "#{File.expand_path(File.dirname(__FILE__))}/../fixtures/custom"
+    assert_equal :custom, @config.ping
+    assert_equal :custom, config2.ping
+  end
+
+  def test_file_in_load_path_returns_true_when_file_is_in_load_path
+    File.stubs(:file?).returns(false)
+    File.stubs(:file?).with("custom/path/for/file.rb").returns(true)
+
+    @config.load_paths << "custom/path/for"
+    assert_equal true, @config.file_in_load_path?("file")
+  end
+
+  def test_file_in_load_path_returns_false_when_file_is_not_in_load_path
+    File.stubs(:file?).returns(false)
+    File.stubs(:file?).with("custom/path/for/file.rb").returns(false)
+
+    @config.load_paths << "custom/path/for"
+    assert_equal false, @config.file_in_load_path?("file")
+  end
+end

data/test/configuration/namespace_dsl_test.rb

@@ -0,0 +1,325 @@
+require "utils"
+require 'minestrone/configuration/namespaces'
+
+class ConfigurationNamespacesDSLTest < Test::Unit::TestCase
+  class MockConfig
+    attr_reader :original_initialize_called, :options
+
+    def initialize
+      @original_initialize_called = true
+      @options = {}
+      initialize_namespaces
+    end
+
+    include Minestrone::Configuration::Namespaces
+  end
+
+  def setup
+    @config = MockConfig.new
+  end
+
+  def test_initialize_should_initialize_collections
+    assert @config.original_initialize_called
+    assert @config.tasks.empty?
+    assert @config.namespaces.empty?
+  end
+
+  def test_unqualified_task_should_define_task_at_top_namespace
+    assert !@config.tasks.key?(:testing)
+    @config.task(:testing) { puts "something" }
+    assert @config.tasks.key?(:testing)
+  end
+
+  def test_qualification_should_define_task_within_namespace
+    @config.namespace(:testing) do
+      task(:nested) { puts "nested" }
+    end
+
+    assert !@config.tasks.key?(:nested)
+    assert @config.namespaces.key?(:testing)
+    assert @config.namespaces[:testing].tasks.key?(:nested)
+  end
+
+  def test_namespace_within_namespace_should_define_task_within_nested_namespace
+    @config.namespace :outer do
+      namespace :inner do
+        task :nested do
+          puts "nested"
+        end
+      end
+    end
+
+    assert !@config.tasks.key?(:nested)
+    assert @config.namespaces.key?(:outer)
+    assert @config.namespaces[:outer].namespaces.key?(:inner)
+    assert @config.namespaces[:outer].namespaces[:inner].tasks.key?(:nested)
+  end
+
+  def test_pending_desc_should_apply_only_to_immediately_subsequent_task
+    @config.desc "A description"
+    @config.task(:testing) { puts "foo" }
+    @config.task(:another) { puts "bar" }
+    assert_equal "A description", @config.tasks[:testing].desc
+    assert_nil @config.tasks[:another].desc
+  end
+
+  def test_pending_desc_should_apply_only_to_next_task_in_any_namespace
+    @config.desc "A description"
+    @config.namespace(:outer) { task(:testing) { puts "foo" } }
+    assert_equal "A description", @config.namespaces[:outer].tasks[:testing].desc
+  end
+
+  def test_defining_task_without_block_should_raise_error
+    assert_raises(ArgumentError) do
+      @config.task(:testing)
+    end
+  end
+
+  def test_defining_task_that_shadows_existing_method_should_raise_error
+    assert_raises(ArgumentError) do
+      @config.task(:sprintf) { puts "foo" }
+    end
+  end
+
+  def test_defining_task_that_shadows_existing_namespace_should_raise_error
+    @config.namespace(:outer) {}
+    assert_raises(ArgumentError) do
+      @config.task(:outer) { puts "foo" }
+    end
+  end
+
+  def test_defining_namespace_that_shadows_existing_method_should_raise_error
+    assert_raises(ArgumentError) do
+      @config.namespace(:sprintf) {}
+    end
+  end
+
+  def test_defining_namespace_that_shadows_existing_task_should_raise_error
+    @config.task(:testing) { puts "foo" }
+    assert_raises(ArgumentError) do
+      @config.namespace(:testing) {}
+    end
+  end
+
+  def test_defining_task_that_shadows_existing_task_should_not_raise_error
+    @config.task(:original) { puts "foo" }
+    assert_nothing_raised do
+      @config.task(:original) { puts "bar" }
+    end
+  end
+
+  def test_defining_ask_should_add_task_as_method
+    assert !@config.methods.any? { |m| m.to_sym == :original }
+    @config.task(:original) { puts "foo" }
+    assert @config.methods.any? { |m| m.to_sym == :original }
+  end
+
+  def test_calling_defined_task_should_delegate_to_execute_task
+    @config.task(:original) { puts "foo" }
+    @config.expects(:execute_task).with(@config.tasks[:original])
+    @config.original
+  end
+
+  def test_name_for_top_level_should_be_nil
+    assert_nil @config.name
+  end
+
+  def test_parent_for_top_level_should_be_nil
+    assert_nil @config.parent
+  end
+
+  def test_fqn_for_top_level_should_be_nil
+    assert_nil @config.fully_qualified_name
+  end
+
+  def test_fqn_for_namespace_should_be_the_name_of_the_namespace
+    @config.namespace(:outer) {}
+    assert_equal "outer", @config.namespaces[:outer].fully_qualified_name
+  end
+
+  def test_parent_for_namespace_should_be_the_top_level
+    @config.namespace(:outer) {}
+    assert_equal @config, @config.namespaces[:outer].parent
+  end
+
+  def test_fqn_for_nested_namespace_should_be_color_delimited
+    @config.namespace(:outer) { namespace(:inner) {} }
+    assert_equal "outer:inner", @config.namespaces[:outer].namespaces[:inner].fully_qualified_name
+  end
+
+  def test_parent_for_nested_namespace_should_be_the_nesting_namespace
+    @config.namespace(:outer) { namespace(:inner) {} }
+    assert_equal @config.namespaces[:outer], @config.namespaces[:outer].namespaces[:inner].parent
+  end
+
+  def test_find_task_should_dereference_nested_tasks
+    @config.namespace(:outer) do
+      namespace(:inner) { task(:nested) { puts "nested" } }
+    end
+
+    task = @config.find_task("outer:inner:nested")
+    assert_not_nil task
+    assert_equal "outer:inner:nested", task.fully_qualified_name
+  end
+
+  def test_find_task_should_return_nil_if_no_task_matches
+    assert_nil @config.find_task("outer:inner:nested")
+  end
+
+  def test_find_task_should_return_default_if_deferences_to_namespace_and_namespace_has_default
+    @config.namespace(:outer) do
+      namespace(:inner) { task(:default) { puts "nested" } }
+    end
+
+    task = @config.find_task("outer:inner")
+    assert_not_nil task
+    assert_equal :default, task.name
+    assert_equal "outer:inner", task.namespace.fully_qualified_name
+  end
+
+  def test_find_task_should_return_nil_if_deferences_to_namespace_and_namespace_has_no_default
+    @config.namespace(:outer) do
+      namespace(:inner) { task(:nested) { puts "nested" } }
+    end
+
+    assert_nil @config.find_task("outer:inner")
+  end
+
+  def test_default_task_should_return_nil_for_top_level
+    @config.task(:default) {}
+    assert_nil @config.default_task
+  end
+
+  def test_default_task_should_return_nil_for_namespace_without_default
+    @config.namespace(:outer) { task(:nested) { puts "nested" } }
+    assert_nil @config.namespaces[:outer].default_task
+  end
+
+  def test_default_task_should_return_task_for_namespace_with_default
+    @config.namespace(:outer) { task(:default) { puts "nested" } }
+    task = @config.namespaces[:outer].default_task
+    assert_not_nil task
+    assert_equal :default, task.name
+  end
+
+  def test_task_list_should_return_only_tasks_immediately_within_namespace
+    @config.task(:first) { puts "here" }
+    @config.namespace(:outer) do
+      task(:second) { puts "here" }
+      namespace(:inner) do
+        task(:third) { puts "here" }
+      end
+    end
+
+    assert_equal %w(first), @config.task_list.map { |t| t.fully_qualified_name }
+  end
+
+  def test_task_list_with_all_should_return_all_tasks_under_this_namespace_recursively
+    @config.task(:first) { puts "here" }
+    @config.namespace(:outer) do
+      task(:second) { puts "here" }
+      namespace(:inner) do
+        task(:third) { puts "here" }
+      end
+    end
+
+    assert_equal %w(first outer:inner:third outer:second), @config.task_list(:all).map { |t| t.fully_qualified_name }.sort
+  end
+
+  def test_namespace_should_respond_to_its_parents_methods
+    @config.namespace(:outer) {}
+    ns = @config.namespaces[:outer]
+    assert ns.respond_to?(:original_initialize_called)
+  end
+
+  def test_namespace_should_accept_respond_to_with_include_priv_parameter
+    @config.namespace(:outer) {}
+    ns = @config.namespaces[:outer]
+    assert ns.respond_to?(:original_initialize_called, true)
+  end
+
+  def test_namespace_should_delegate_unknown_messages_to_its_parent
+    @config.namespace(:outer) {}
+    ns = @config.namespaces[:outer]
+    assert ns.original_initialize_called
+  end
+
+  def test_namespace_should_not_understand_messages_that_neither_it_nor_its_parent_understands
+    @config.namespace(:outer) {}
+    ns = @config.namespaces[:outer]
+    assert_raises(NoMethodError) { ns.alskdfjlsf }
+  end
+
+  def test_search_task_should_find_tasks_in_current_namespace
+    @config.namespace(:outer) do
+      namespace(:inner) do
+        task(:third) { puts "here" }
+      end
+    end
+
+    inner = @config.namespaces[:outer].namespaces[:inner]
+    assert_equal inner.tasks[:third], inner.search_task(:third)
+  end
+
+  def test_search_task_should_find_tasks_in_parent_namespace
+    @config.task(:first) { puts "here" }
+    @config.namespace(:outer) do
+      task(:second) { puts "here" }
+      namespace(:inner) do
+        task(:third) { puts "here" }
+      end
+    end
+
+    inner = @config.namespaces[:outer].namespaces[:inner]
+    assert_equal @config.tasks[:first], inner.search_task(:first)
+  end
+
+  def test_search_task_should_return_nil_if_no_tasks_are_found
+    @config.namespace(:outer) { namespace(:inner) {} }
+    inner = @config.namespaces[:outer].namespaces[:inner]
+    assert_nil inner.search_task(:first)
+  end
+
+  def test_top_should_return_self_if_self_is_top
+    assert_equal @config, @config.top
+  end
+
+  def test_top_should_return_parent_if_parent_is_top
+    @config.namespace(:outer) {}
+    assert_equal @config, @config.namespaces[:outer].top
+  end
+
+  def test_top_should_return_topmost_parent_if_self_is_deeply_nested
+    @config.namespace(:outer) { namespace(:middle) { namespace(:inner) {} } }
+    assert_equal @config, @config.namespaces[:outer].namespaces[:middle].namespaces[:inner].top
+  end
+
+  def test_find_task_should_return_nil_when_empty_inner_task
+    @config.namespace :outer do
+      namespace :inner do
+      end
+    end
+    assert_nil @config.find_task("outer::inner")
+  end
+
+  def test_kernel_method_clashing_should_not_affect_method_delegation_to_parent
+    @config.class.class_eval do
+      def some_weird_method() 'config' end
+    end
+
+    @config.namespace(:clash) {}
+    namespace = @config.namespaces[:clash]
+    assert_equal 'config', namespace.some_weird_method
+
+    Kernel.module_eval do
+      def some_weird_method() 'kernel' end
+    end
+
+    @config.namespace(:clash2) {}
+    namespace = @config.namespaces[:clash2]
+    assert_equal 'config', namespace.some_weird_method
+
+    Kernel.send :remove_method, :some_weird_method
+    @config.class.send :remove_method, :some_weird_method
+  end
+end

data/test/configuration/servers_test.rb

@@ -0,0 +1,100 @@
+require "utils"
+require 'minestrone/task_definition'
+require 'minestrone/configuration/servers'
+
+class ConfigurationServersTest < Test::Unit::TestCase
+  class MockConfig
+    def initialize
+      initialize_servers
+    end
+
+    include Minestrone::Configuration::Servers
+  end
+
+  def setup
+    @config = MockConfig.new
+    @config.server "app1", :user => "deploy", :port => 2222, :ssh_options => { :forward_agent => true }
+  end
+
+  def teardown
+    ENV.delete('HOSTS')
+    ENV.delete('SERVER')
+  end
+
+  def test_resolved_server_should_return_the_configured_server
+    assert_equal "app1", @config.resolved_server.host
+  end
+
+  def test_server_should_keep_connection_options
+    server = @config.resolved_server
+    assert_equal "deploy", server.user
+    assert_equal 2222, server.port
+    assert_equal({ :forward_agent => true }, server.options[:ssh_options])
+  end
+
+  def test_server_environment_variable_should_replace_configured_host
+    ENV['SERVER'] = "override"
+    server = @config.resolved_server
+    assert_equal "override", server.host
+    assert_equal "deploy", server.user
+    assert_equal 2222, server.port
+    assert_equal({ :forward_agent => true }, server.options[:ssh_options])
+  end
+
+  def test_server_environment_variable_can_include_user_and_port
+    ENV['SERVER'] = "other@override:2022"
+    server = @config.resolved_server
+    assert_equal "override", server.host
+    assert_equal "other", server.user
+    assert_equal 2022, server.port
+  end
+
+  def test_server_environment_variable_must_not_be_blank
+    ENV['SERVER'] = " "
+    assert_raises(ArgumentError) { @config.resolved_server }
+  end
+
+  def test_hosts_environment_variable_should_replace_configured_host_as_fallback
+    ENV['HOSTS'] = "override"
+    server = @config.resolved_server
+    assert_equal "override", server.host
+    assert_equal "deploy", server.user
+    assert_equal 2222, server.port
+    assert_equal({ :forward_agent => true }, server.options[:ssh_options])
+  end
+
+  def test_server_environment_variable_should_take_precedence_over_hosts
+    ENV['SERVER'] = "override"
+    ENV['HOSTS'] = "fallback"
+    assert_equal "override", @config.resolved_server.host
+  end
+
+  def test_hosts_environment_variable_must_name_a_single_server
+    ENV['HOSTS'] = "app1,app2"
+    assert_raises(ArgumentError) { @config.resolved_server }
+  end
+
+  def test_host_environment_variable_should_not_replace_configured_host
+    ENV['HOST'] = "override"
+    assert_equal "app1", @config.resolved_server.host
+  end
+
+  def test_resolved_server_should_raise_when_no_server_is_configured
+    config = MockConfig.new
+    assert_raises(Minestrone::NoMatchingServersError) { config.resolved_server }
+  end
+
+  def test_server_should_reject_multiple_hosts
+    config = MockConfig.new
+    assert_raises(ArgumentError) { config.server "app1", "app2" }
+  end
+
+  def test_server_should_reject_comma_separated_hosts
+    config = MockConfig.new
+    assert_raises(ArgumentError) { config.server "app1,app2" }
+  end
+
+  def test_server_should_reject_a_second_definition
+    assert_raises(ArgumentError) { @config.server "app2" }
+  end
+end