knife-solo 0.0.15 → 0.1.0.pre1

data/test/solo_prepare_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+require 'support/kitchen_helper'
+require 'support/validation_helper'
+
+require 'chef/knife/solo_prepare'
+
+class SoloPrepareTest < TestCase
+  include KitchenHelper
+  include ValidationHelper::ValidationTests
+
+  def setup
+    @host = 'someuser@somehost.domain.com'
+  end
+
+  def test_will_specify_omnibus_version
+    in_kitchen do
+      run_command = command(@host, "--omnibus-version", "'0.10.8-3'")
+      assert_match "0.10.8-3", run_command.config[:omnibus_version]
+    end
+  end
+
+  def test_run_raises_if_operating_system_is_not_supported
+    in_kitchen do
+      run_command = command(@host)
+      run_command.stubs(:required_files_present?).returns(true)
+      run_command.stubs(:operating_system).returns('MythicalOS')
+      assert_raises KnifeSolo::Bootstraps::OperatingSystemNotImplementedError do
+        run_command.run
+      end
+    end
+  end
+
+  def test_run_calls_bootstrap
+    in_kitchen do
+      run_command = command(@host)
+      bootstrap_instance = mock('mock OS bootstrap instance')
+      run_command.stubs(:required_files_present?).returns(true)
+      run_command.stubs(:operating_system).returns('MythicalOS')
+      run_command.stubs(:bootstrap).returns(bootstrap_instance)
+
+      bootstrap_instance.expects(:bootstrap!)
+
+      run_command.run
+    end
+  end
+
+  def command(*args)
+    knife_command(Chef::Knife::SoloPrepare, *args)
+  end
+end

data/test/ssh_command_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+require 'knife-solo/ssh_command'
+require 'chef/knife'
+require 'net/ssh'
+
+class DummySshCommand < Chef::Knife
+  include KnifeSolo::SshCommand
+end
+
+class SshCommandTest < TestCase
+  def test_separates_user_and_host
+    assert_equal "ubuntu", command("ubuntu@10.0.0.1").user
+    assert_equal "10.0.0.1", command("ubuntu@10.0.0.1").host
+  end
+
+  def test_defaults_to_system_user
+    ENV['USER'] = "test"
+    assert_equal "test", command("10.0.0.1").user
+  end
+
+  def test_host_regex_rejects_invalid_hostnames
+    %w[@name @@name.com name@ name@@ joe@@example.com joe@name@example.com].each do |invalid|
+      cmd = command(invalid)
+      refute cmd.first_cli_arg_is_a_hostname?, "#{invalid} should have been rejected"
+    end
+  end
+
+  def test_host_regex_accpets_valid_hostnames
+    %w[name.com name joe@example.com].each do |valid|
+      cmd = command(valid)
+      assert cmd.first_cli_arg_is_a_hostname?, "#{valid} should have been accepted"
+    end
+  end
+
+  def test_prompts_for_password_if_not_provided
+    cmd = command("10.0.0.1")
+    cmd.ui.expects(:ask).returns("testpassword")
+    assert_equal "testpassword", cmd.password
+  end
+
+  def test_falls_back_to_password_authentication_after_keys
+    cmd = command("10.0.0.1", "--ssh-password=test")
+    cmd.expects(:try_connection).raises(Net::SSH::AuthenticationFailed)
+    cmd.detect_authentication_method
+    assert_equal "test", cmd.connection_options[:password]
+  end
+
+  def test_uses_default_keys_if_conncetion_succeeds
+    cmd = command("10.0.0.1")
+    assert_equal({}, cmd.connection_options)
+  end
+
+  def test_uses_ssh_config_if_matched
+    ssh_config = Pathname.new(__FILE__).dirname.join('support', 'ssh_config')
+    cmd = command("10.0.0.1", "--ssh-config-file=#{ssh_config}")
+
+    assert_equal "bob", cmd.connection_options[:user]
+    assert_equal "id_rsa_bob", cmd.connection_options[:keys].first
+    assert_equal "bob", cmd.user
+  end
+
+  def test_handles_port_specification
+    cmd = command("10.0.0.1", "-p", "2222")
+    assert_equal "2222", cmd.connection_options[:port]
+  end
+
+  def test_handle_startup_script
+    cmd = command("10.0.0.1", "--startup-script=~/.bashrc")
+    assert_equal "source ~/.bashrc && echo $TEST_PROP",  cmd.processed_command("echo $TEST_PROP")
+  end
+
+  def test_builds_cli_ssh_args
+    DummySshCommand.any_instance.stubs(:try_connection)
+
+    cmd = command("10.0.0.1")
+    assert_equal "#{ENV['USER']}@10.0.0.1", cmd.ssh_args
+
+    cmd = command("usertest@10.0.0.1", "--ssh-config-file=myconfig")
+    assert_equal "usertest@10.0.0.1 -F myconfig", cmd.ssh_args
+
+    cmd = command("usertest@10.0.0.1", "--ssh-identity=my_rsa")
+    assert_equal "usertest@10.0.0.1 -i my_rsa", cmd.ssh_args
+
+    cmd = command("usertest@10.0.0.1", "--ssh-port=222")
+    assert_equal "usertest@10.0.0.1 -p 222", cmd.ssh_args
+  end
+
+  def test_barks_without_atleast_a_hostname
+    cmd = command
+    cmd.ui.expects(:err).with(regexp_matches(/hostname.*argument/))
+    $stdout.stubs(:puts)
+    assert_exits { cmd.validate_first_cli_arg_is_a_hostname! }
+  end
+
+  def command(*args)
+    Net::SSH::Config.stubs(:default_files)
+    knife_command(DummySshCommand, *args)
+  end
+end

data/test/support/config.yml.example

@@ -0,0 +1,4 @@
+aws:
+  key_name: knife-solo
+  access_key: YOUR_ACCESS_KEY
+  secret: YOUR_SECRET

data/test/support/data_bag_key

@@ -0,0 +1 @@
+dZkd2eosIBc+4dWfDjFgwyc+sj0XlCBRR5/nVbA23sA4RAlg0pd+RIh4GiPpwp3IGPslJhapNX36bkPbjXjsyGzxKt2kZth9Z5Ucw9tC8jEnWtfxs66xABmZQvE/WGEdBZ3UDEbBaEBSjznVpHlXI//oLd1bU83nyV21i4OYW6eDc7h47mdbu59tvY8q4Doks8nwmoTMbTqzWkD2CRxx2Z5x2kqBb+HAXRI6KZK7vqvhAGYcm1d/vLkCGp/2ntDvRHEGmjbtJHDVD+0qJIf7w5W9jumhVkFTOPBym7P5i3OkAbO3RSsKHb2iRUlAw4Sld21pZBtBc5sDXJ/AUVzV+c/rsmvZDf01TWg9RoIN82928qnlCfJohmJGHTVt0Q5rf/DYOtk7DBCSsOkOChYdX8pRJG2+A5ACvALjXmd/5qUYUGuHe9m7PzNHV+37GOnlHBYqkZ5EU0LGjLMqq0Tgs/KzWpeotRK/VPNwmCrYCMwYwJtRKi1oMexUwDLrBcTilivp+62e9HFhSg0BRV0JlJcPgYRWqJ2RyBkrmOXv7lD10tPVnMzbwi+5yW131e9JbvgdBreJ2Ph314XyxjQvFNkQ/vny6iiisJEquwVBJTnqW+HdjIH07MeqkdaVytdMLlTSdgqGr/rIf1ZNS37jeq0AT8Y8YeihQNsnx559hu4=

data/test/support/ec2_runner.rb

@@ -0,0 +1,122 @@
+require 'yaml'
+
+# A custom runner that serves as a common point for EC2 control
+class EC2Runner < MiniTest::Unit
+  include Loggable
+
+  def initialize
+    super
+    create_key_pair
+  end
+
+  def skip_destroy?
+    ENV['SKIP_DESTROY']
+  end
+
+  def user
+    ENV['USER']
+  end
+
+  # Gets a server for the given tests
+  # See http://bit.ly/MJRpfQ for information on what filters can be specified.
+  def get_server(test)
+    server = compute.servers.all("tag-key"             => "name",
+                                 "tag-value"           => test.server_name,
+                                 "instance-state-name" => "running").first
+    if server
+      logger.info "Reusing active server tagged #{test.server_name}"
+    else
+      logger.info "Starting server for #{test.class}..."
+      server = compute.servers.create(:tags => {
+                                        :name => test.server_name,
+                                        :knife_solo_integration_user => ENV['USER']
+                                      },
+                                      :image_id => test.image_id,
+                                      :flavor_id => test.flavor_id,
+                                      :key_name => key_name)
+    end
+    server.wait_for { ready? }
+    logger.info "#{test.class} server (#{server.dns_name}) reported ready, trying to connect to ssh..."
+    server.wait_for do
+      `nc #{public_ip_address} 22 -w 1 -q 0 </dev/null`
+      $?.success?
+    end
+    logger.info "Sleeping 10s to avoid Net::SSH locking up by connecting too early..."
+    logger.info "  (if you know a better way, please send me a note at https://github.com/matschaffer/knife-solo)"
+    # These may have better ways:
+    # http://rubydoc.info/gems/fog/Fog/Compute/AWS/Server:setup
+    # http://rubydoc.info/gems/knife-ec2/Chef/Knife/Ec2ServerCreate:tcp_test_ssh
+    sleep 10
+    server
+  end
+
+  # Adds a knife_solo_prepared tag to the server so we can know not to re-prepare it
+  def tag_as_prepared(server)
+    compute.tags.create(resource_id: server.identity,
+                        key:         :knife_solo_prepared,
+                        value:       true)
+  end
+
+  # Cleans up all the servers tagged as knife solo servers for this user.
+  # Specify SKIP_DESTROY environment variable to skip this step and leave servers
+  # running for inspection or reuse.
+  def run_ec2_cleanup
+    servers = compute.servers.all("tag-key"             => "knife_solo_integration_user",
+                                  "tag-value"           => user,
+                                  "instance-state-name" => "running")
+    if skip_destroy?
+      puts "\nSKIP_DESTROY specified, leaving #{servers.size} instances running"
+    else
+      puts <<-TXT.gsub(/^\s*/, '')
+          ===
+          About to terminate the following instances. Please cancel (Control-C)
+          NOW if you want to leave them running. Use SKIP_DESTROY=true to
+          skip this step.
+      TXT
+      servers.each do |server|
+        puts "  * #{server.id}"
+      end
+      sleep 20
+      servers.each do |server|
+        logger.info "Destroying #{server.public_ip_address}..."
+        server.destroy
+      end
+    end
+  end
+
+  # Attempts to create the keypair used for integration testing
+  # unless the key file is already present locally.
+  def create_key_pair
+    return if key_file.exist?
+    begin
+      key = compute.key_pairs.create(:name => key_name)
+      key.write(key_file)
+    rescue Fog::Compute::AWS::Error => e
+      raise "Unable to create KeyPair 'knife-solo', please create the keypair and save it to #{key_file}"
+    end
+  end
+
+  def key_name
+    config['aws']['key_name']
+  end
+
+  def key_file
+    $base_dir.join('support', "#{key_name}.pem")
+  end
+
+  def config_file
+    $base_dir.join('support', 'config.yml')
+  end
+
+  def config
+    @config ||= YAML.load_file(config_file)
+  end
+
+  # Provides a Fog compute resource associated with the
+  # AWS account credentials provided in test/support/config.yml
+  def compute
+    @compute ||= Fog::Compute.new({:provider              => 'AWS',
+                                   :aws_access_key_id     => config['aws']['access_key'],
+                                   :aws_secret_access_key => config['aws']['secret']})
+  end
+end

data/test/support/integration_test.rb

@@ -0,0 +1,94 @@
+require 'json'
+require 'net/http'
+
+require 'support/test_case'
+
+case_pattern = $base_dir.join('integration', 'cases', '*.rb')
+Dir[case_pattern].each do |use_case|
+  require use_case
+end
+
+# Base class for EC2 integration tests
+class IntegrationTest < TestCase
+  include Loggable
+
+  # Returns a name for the current test's server
+  # that should be fairly unique.
+  def server_name
+    "knife_solo-#{image_id}"
+  end
+
+  # Shortcut to access the test runner
+  def runner
+    MiniTest::Unit.runner
+  end
+
+  # Returns the server for this test, retrieved from the test runner
+  def server
+    return @server if @server
+    @server = runner.get_server(self)
+  end
+
+  # The flavor to run this test on
+  def flavor_id
+    "m1.small"
+  end
+
+  # Sets up a kitchen directory to work in
+  def setup
+    @kitchen = $base_dir.join('support', 'kitchens', self.class.to_s)
+    FileUtils.remove_entry_secure(@kitchen, true)
+    @kitchen.dirname.mkpath
+    system "knife solo init #{@kitchen} >> #{log_file}"
+    @start_dir = Dir.pwd
+    Dir.chdir(@kitchen)
+    prepare_server
+  end
+
+  # Gets back to the start dir
+  def teardown
+    Dir.chdir(@start_dir)
+  end
+
+  # Writes out the given node hash as a json file
+  def write_nodefile(node)
+    write_json_file("nodes/#{server.public_ip_address}.json", node)
+  end
+
+  # Writes out an object to the given file as JSON
+  def write_json_file(file, data)
+    FileUtils.mkpath(File.dirname(file))
+    File.open(file, 'w') do |f|
+      f.print data.to_json
+    end
+  end
+
+  # Prepares the server unless it has already been marked as such
+  def prepare_server
+    return if server.tags["knife_solo_prepared"]
+    assert_subcommand prepare_command
+    runner.tag_as_prepared(server)
+  end
+
+  # The prepare command to use on this server
+  def prepare_command
+    "prepare"
+  end
+
+  # Provides the path to the runner's key file
+  def key_file
+    runner.key_file
+  end
+
+  # The ssh-style connection string used to connect to the current node
+  def connection_string
+    "-i #{key_file} #{user}@#{server.public_ip_address}"
+  end
+
+  # Asserts that a prepare or cook command is successful
+  def assert_subcommand(subcommand)
+    system "knife solo #{subcommand} #{connection_string} -VV >> #{log_file}"
+    assert $?.success?
+  end
+end
+

data/test/support/issue_files/gentoo2011

@@ -0,0 +1,3 @@
+
+This is \n.\O (\s \m \r) \t
+

data/test/support/issue_files/sles11-sp1

@@ -0,0 +1,4 @@
+
+Welcome to SUSE Linux Enterprise Server 11 SP1  (x86_64) - Kernel \r (\l).
+
+

data/test/support/issue_files/ubuntu

@@ -0,0 +1,2 @@
+Ubuntu 10.04.3 LTS \n \l
+

data/test/support/kitchen_helper.rb

@@ -0,0 +1,22 @@
+require 'tmpdir'
+
+require 'chef/knife/solo_init'
+
+module KitchenHelper
+
+  def in_kitchen
+    outside_kitchen do
+      knife_command(Chef::Knife::SoloInit, ".").run
+      yield
+    end
+  end
+
+  def outside_kitchen
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        yield
+      end
+    end
+  end
+
+end

data/test/support/loggable.rb

@@ -0,0 +1,18 @@
+require 'logger'
+
+# A module that provides logger and log_file attached to an integration log file
+module Loggable
+  # The file that logs will go do, using the class name as a differentiator
+  def log_file
+    return @log_file if @log_file
+    @log_file = $base_dir.join('..', 'log', "#{self.class}-integration.log")
+    @log_file.dirname.mkpath
+    @log_file
+  end
+
+  # The logger object so you can say logger.info to log messages
+  def logger
+    @logger ||= Logger.new(log_file)
+  end
+end
+

data/test/support/secret_cookbook/metadata.rb

@@ -0,0 +1,5 @@
+maintainer       "Mat Schaffer"
+maintainer_email "mat@schaffer.me"
+license          "MIT"
+description      "Spits out a file containing a secret data bag value"
+version          "0.0.1"

data/test/support/secret_cookbook/recipes/default.rb

@@ -0,0 +1,8 @@
+passwords = Chef::EncryptedDataBagItem.load("dev", "passwords")
+
+file "/etc/admin_password" do
+  # This mode is a terrible idea for passwords
+  # but makes verification easier
+  mode 0644
+  content passwords["admin"]
+end