knife-solo 0.0.15 → 0.1.0.pre1

data/test/integration/omnios_r151004_test.rb

@@ -0,0 +1,14 @@
+require 'integration_helper'
+
+class OmniOSr151004Test < IntegrationTest
+  def user
+    "root"
+  end
+
+  def image_id
+    "ami-4e2c9727"
+  end
+
+  include EmptyCook
+  include EncryptedDataBag
+end

data/test/integration/scientific_linux_63_test.rb

@@ -0,0 +1,15 @@
+require 'integration_helper'
+
+class ScientificLinux63Test < IntegrationTest
+  def user
+    "root"
+  end
+
+  def image_id
+    "ami-313b8e58"
+  end
+
+  include EmptyCook
+  #include Apache2Cook
+  include EncryptedDataBag
+end

data/test/integration/sles_11_test.rb

@@ -0,0 +1,14 @@
+require 'integration_helper'
+
+class Sles11_Test < IntegrationTest
+  def user
+    "root"
+  end
+
+  def image_id
+    "ami-ca32efa3"
+  end
+
+  include EmptyCook
+  include EncryptedDataBag
+end

data/test/integration/ubuntu10_04_test.rb

@@ -0,0 +1,15 @@
+require 'integration_helper'
+
+class Ubuntu10_04Test < IntegrationTest
+  def user
+    "ubuntu"
+  end
+
+  def image_id
+    "ami-6936fb00"
+  end
+
+  include EmptyCook
+  include Apache2Cook
+  include EncryptedDataBag
+end

data/test/integration/ubuntu12_04_bootstrap_test.rb

@@ -0,0 +1,17 @@
+require 'integration_helper'
+
+class Ubuntu12_04BootstrapTest < IntegrationTest
+  def user
+    "ubuntu"
+  end
+
+  def image_id
+    "ami-9a873ff3"
+  end
+
+  def prepare_server
+    # Do nothing as `solo bootstrap` will do everything
+  end
+
+  include Apache2Bootstrap
+end

data/test/integration/ubuntu12_04_test.rb

@@ -0,0 +1,15 @@
+require 'integration_helper'
+
+class Ubuntu12_04Test < IntegrationTest
+  def user
+    "ubuntu"
+  end
+
+  def image_id
+    "ami-9a873ff3"
+  end
+
+  include EmptyCook
+  include Apache2Cook
+  include EncryptedDataBag
+end

data/test/integration_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require
+require 'minitest/parallel'
+Bundler.require(:test)
+
+require 'pathname'
+$base_dir = Pathname.new(__FILE__).dirname
+
+require 'support/loggable'
+require 'support/ec2_runner'
+require 'support/integration_test'
+
+MiniTest::Parallel.processor_count = 5
+MiniTest::Unit.runner = EC2Runner.new

data/test/kitchen_command_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+require 'support/kitchen_helper'
+
+require 'chef/knife'
+require 'knife-solo/kitchen_command'
+
+class DummyKitchenCommand < Chef::Knife
+  include KnifeSolo::KitchenCommand
+end
+
+class KitchenCommandTest < TestCase
+  include KitchenHelper
+
+  def test_barks_outside_of_the_kitchen
+    cmd = command
+    cmd.ui.expects(:err).with(regexp_matches(/must be run inside .* kitchen/))
+    outside_kitchen do
+      assert_exits { cmd.validate_kitchen! }
+    end
+  end
+
+  def test_runs_when_in_a_kitchen
+    in_kitchen do
+      command.validate_kitchen!
+    end
+  end
+
+  def command(*args)
+    knife_command(DummyKitchenCommand, *args)
+  end
+end

data/test/minitest/parallel.rb

@@ -0,0 +1,41 @@
+# https://github.com/ngauthier/minitest-parallel
+if defined?(MiniTest)
+  raise "Do not require minitest before minitest/parallel\n"
+end
+require 'parallel'
+require 'minitest/unit'
+
+module MiniTest::Parallel
+  def self.included(base)
+    base.class_eval do
+      alias_method :_run_suites_in_series, :_run_suites
+      alias_method :_run_suites, :_run_suites_in_parallel
+    end
+  end
+
+  def self.processor_count=(procs)
+    @processor_count = procs
+  end
+
+  def self.processor_count
+    @processor_count ||= Parallel.processor_count
+  end
+
+  def _run_suites_in_parallel(suites, type)
+    result = Parallel.map(suites, :in_processes => MiniTest::Parallel.processor_count) do |suite|
+      ret = _run_suite(suite, type)
+      {
+        :failures         => failures,
+        :errors           => errors,
+        :report           => report,
+        :run_suite_return => ret
+      }
+    end
+    self.failures = result.inject(0)  {|sum, x| sum + x[:failures] }
+    self.errors   = result.inject(0)  {|sum, x| sum + x[:errors] }
+    self.report   = result.inject([]) {|sum, x| sum + x[:report] }
+    result.map {|x| x[:run_suite_return] }
+  end
+end
+
+MiniTest::Unit.send(:include, MiniTest::Parallel)

data/test/node_config_command_test.rb

@@ -0,0 +1,101 @@
+require 'test_helper'
+require 'support/kitchen_helper'
+
+require 'chef/knife'
+require 'knife-solo/node_config_command'
+
+class DummyNodeConfigCommand < Chef::Knife
+  include KnifeSolo::NodeConfigCommand
+
+  # This is normally declared in KnifeSolo::SshCommand
+  def host
+    @name_args.first
+  end
+end
+
+class NodeConfigCommandTest < TestCase
+  include KitchenHelper
+
+  def setup
+    @host = "defaulthost"
+  end
+
+  def test_node_config_defaults_to_host_name
+    cmd = command(@host)
+    assert_equal "nodes/#{@host}.json", cmd.node_config.to_s
+  end
+
+  def test_takes_node_config_as_second_arg
+    cmd = command(@host, "nodes/myhost.json")
+    assert_equal "nodes/myhost.json", cmd.node_config.to_s
+  end
+
+  def test_takes_node_config_from_option
+    cmd = command(@host, "--node-name=mynode")
+    assert_equal "nodes/mynode.json", cmd.node_config.to_s
+  end
+
+  def test_takes_node_config_as_second_arg_even_with_name_option
+    cmd = command(@host, "nodes/myhost.json", "--node-name=mynode")
+    assert_equal "nodes/myhost.json", cmd.node_config.to_s
+  end
+
+  def test_generates_a_node_config
+    in_kitchen do
+      cmd = command(@host)
+      cmd.generate_node_config
+      assert cmd.node_config.exist?
+      assert_match '{"run_list":[]}', cmd.node_config.read
+    end
+  end
+
+  def test_wont_overwrite_node_config
+    in_kitchen do
+      cmd = command(@host, "--run-list=role[myrole]")
+      File.open(cmd.node_config, "w") do |f|
+        f << "testdata"
+      end
+      cmd.generate_node_config
+      assert_match "testdata", cmd.node_config.read
+    end
+  end
+
+  def test_generates_a_node_config_from_name_option
+    in_kitchen do
+      cmd = command(@host, "--node-name=mynode")
+      cmd.generate_node_config
+      assert cmd.node_config.exist?
+    end
+  end
+
+  def test_generates_a_node_config_with_specified_run_list
+    in_kitchen do
+      cmd = command(@host, "--run-list=role[base],recipe[foo]")
+      cmd.generate_node_config
+      assert_match '{"run_list":["role[base]","recipe[foo]"]}', cmd.node_config.read
+    end
+  end
+
+  def test_generates_a_node_config_with_specified_attributes
+    in_kitchen do
+      foo_json = '"foo":{"bar":[1,2],"baz":"x"}'
+      cmd = command(@host, "--json-attributes={#{foo_json}}")
+      cmd.generate_node_config
+      assert_match "{#{foo_json},\"run_list\":[]}", cmd.node_config.read
+    end
+  end
+
+  def test_generates_a_node_config_with_specified_run_list_and_attributes
+    in_kitchen do
+      foo_json = '"foo":"bar"'
+      run_list = 'recipe[baz]'
+      cmd = command(@host, "--run-list=#{run_list}", "--json-attributes={#{foo_json}}")
+      cmd.generate_node_config
+      assert_match "{#{foo_json},\"run_list\":[\"#{run_list}\"]}", cmd.node_config.read
+    end
+  end
+
+  def command(*args)
+    knife_command(DummyNodeConfigCommand, *args)
+  end
+end

data/test/solo_bootstrap_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+require 'support/kitchen_helper'
+require 'support/validation_helper'
+
+require 'chef/knife/solo_bootstrap'
+require 'chef/knife/solo_cook'
+require 'chef/knife/solo_prepare'
+
+class SoloBootstrapTest < TestCase
+  include KitchenHelper
+  include ValidationHelper::ValidationTests
+
+  def test_includes_all_prepare_options
+    bootstrap_options = Chef::Knife::SoloBootstrap.options
+    Chef::Knife::SoloPrepare.new.options.keys.each do |opt_key|
+      assert bootstrap_options.include?(opt_key), "Should support option :#{opt_key}"
+    end
+  end
+
+  def test_runs_prepare_and_cook
+    Chef::Knife::SoloPrepare.any_instance.expects(:run)
+    Chef::Knife::SoloCook.any_instance.expects(:run)
+
+    in_kitchen do
+      command("somehost").run
+    end
+  end
+
+  def command(*args)
+    knife_command(Chef::Knife::SoloBootstrap, *args)
+  end
+end

data/test/solo_clean_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+require 'support/validation_helper'
+
+require 'chef/knife/solo_clean'
+
+class SoloCleanTest < TestCase
+  include ValidationHelper::ValidationTests
+
+  def command(*args)
+    knife_command(Chef::Knife::SoloClean, *args)
+  end
+end

data/test/solo_cook_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+require 'support/kitchen_helper'
+require 'support/validation_helper'
+
+require 'chef/cookbook/chefignore'
+require 'chef/knife/solo_cook'
+
+class SuccessfulResult
+  def success?
+    true
+  end
+end
+
+class SoloCookTest < TestCase
+  include KitchenHelper
+  include ValidationHelper::ValidationTests
+
+  def test_gets_destination_path_from_chef_config
+    Chef::Config.file_cache_path "/tmp/chef-solo"
+    assert_equal "/tmp/chef-solo", command.chef_path
+  end
+
+  def test_gets_patch_path_from_chef_config
+    Chef::Config.cookbook_path ["/tmp/chef-solo/cookbooks"]
+    assert_equal "/tmp/chef-solo/cookbooks/chef_solo_patches/libraries", command.patch_path
+  end
+
+  def test_chefignore_is_valid_object
+    assert_instance_of Chef::Cookbook::Chefignore, command.chefignore
+  end
+
+  def test_rsync_exclude_sources_chefignore
+    in_kitchen do
+      file_to_ignore = "dummy.txt"
+      File.open(file_to_ignore, 'w') {|f| f.puts "This file should be ignored"}
+      File.open("chefignore", 'w') {|f| f.puts file_to_ignore}
+      assert command.rsync_exclude.include?(file_to_ignore), "#{file_to_ignore} should have been excluded"
+    end
+  end
+
+  def test_passes_node_name_to_chef_solo
+    assert_chef_solo_option "--node-name=mynode", "-N mynode"
+  end
+
+  def test_passes_whyrun_mode_to_chef_solo
+    assert_chef_solo_option "--why-run", "-W"
+  end
+
+  # Asserts that the chef_solo_option is passed to chef-solo iff cook_option
+  # is specified for the cook command
+  def assert_chef_solo_option(cook_option, chef_solo_option)
+    matcher = regexp_matches(/\s#{Regexp.quote(chef_solo_option)}(\s|$)/)
+    in_kitchen do
+      cmd = command("somehost", cook_option)
+      cmd.expects(:stream_command).with(matcher).returns(SuccessfulResult.new)
+      cmd.cook
+
+      cmd = command("somehost")
+      cmd.expects(:stream_command).with(Not(matcher)).returns(SuccessfulResult.new)
+      cmd.cook
+    end
+  end
+
+  def command(*args)
+    knife_command(Chef::Knife::SoloCook, *args)
+  end
+end

data/test/solo_init_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+require 'support/kitchen_helper'
+
+require 'chef/knife/solo_init'
+
+class SoloInitTest < TestCase
+  include KitchenHelper
+
+  def test_produces_folders
+    in_kitchen do
+      assert File.exist?("nodes")
+    end
+  end
+
+  def test_produces_gitkeep_in_folders
+    in_kitchen do
+      assert File.exist?("nodes/.gitkeep")
+    end
+  end
+
+  def test_barks_without_directory_arg
+    cmd = command
+    cmd.ui.expects(:err).with(regexp_matches(/You must specify a directory/))
+    $stdout.stubs(:puts)
+    outside_kitchen do
+      assert_exits cmd
+    end
+  end
+
+  def test_takes_directory_as_arg
+    outside_kitchen do
+      command("new_kitchen").run
+      assert File.exist?("new_kitchen/nodes")
+    end
+  end
+
+  def command(*args)
+    knife_command(Chef::Knife::SoloInit, *args)
+  end
+end