kitchen-linode 0.10.0 → 0.11.0

data/.travis.yml

@@ -1,11 +1,11 @@
 language: ruby
 
 rvm:
-- 2.0.0
-- 1.9.3
-- 1.9.2
-- ruby-head
+- 2.3.0
+- 2.1.5
 
-matrix:
-  allow_failures:
-  - rvm: ruby-head
+script: "bundle exec rspec"
+
+addons:
+  code_climate:
+    repo_token: e6d4bb7235b740943569bfe50196b620353970884a75f466d11cd37a2fc250f6

data/Gemfile

@@ -1,6 +1,3 @@
 source "http://rubygems.org"
 
 gemspec
-
-gem 'rspec', '~> 3.0'
-

data/README.md

@@ -1,19 +1,29 @@
 # <a name="title"></a> Kitchen::Linode
+[![Gem](https://img.shields.io/gem/v/kitchen-linode.svg)](https://rubygems.org/gems/kitchen-linode)
+[![Gem](https://img.shields.io/gem/dt/kitchen-linode.svg)](https://rubygems.org/gems/kitchen-linode)
+[![Gem](https://img.shields.io/gem/dtv/kitchen-linode.svg)](https://rubygems.org/gems/kitchen-linode)
+[![Code Climate](https://codeclimate.com/github/ssplatt/kitchen-linode/badges/gpa.svg)](https://codeclimate.com/github/ssplatt/kitchen-linode)
+[![Test Coverage](https://codeclimate.com/github/ssplatt/kitchen-linode/badges/coverage.svg)](https://codeclimate.com/github/ssplatt/kitchen-linode/coverage)
+[![Build Status](https://travis-ci.org/ssplatt/kitchen-linode.svg?branch=master)](https://travis-ci.org/ssplatt/kitchen-linode)
 
-A Test Kitchen Driver for Linode.
+A Test Kitchen Driver for [Linode](http://www.linode.com).
+
+[![asciicast](https://asciinema.org/a/44348.png)](https://asciinema.org/a/44348)
 
 ## <a name="requirements"></a> Requirements
 
-**TODO:** document any software or library prerequisites that are required to
-use this driver. Implement the `#verify_dependencies` method in your Driver
-class to enforce these requirements in code, if possible.
+Requires [Test Kitchen](http://kitchen-ci.org) and a [Linode](http://www.linode.com) account.
+```
+gem install test-kitchen
+```
 
 ## <a name="installation"></a> Installation and Setup
 
-Install the gem file:
+The gem file is hosted at [RubyGems](https://rubygems.org/gems/kitchen-linode). To install the gem file, run:
 ```
 gem install kitchen-linode
 ```
+Or, install with bundler if you have a Gemfile
 Please read the [Driver usage][driver_usage] page for more details.
 
 ## <a name="config"></a> Configuration
@@ -21,12 +31,12 @@ Please read the [Driver usage][driver_usage] page for more details.
 For many of these, you can specify an ID number, a full name, or a partial name that will try to match something in the list but may not match exactly what you want.
 ```
 LINODE_API_KEY      Linode API Key environment variable, default: nil
-:username           ssh user name, default: 'root'
+:username           ssh user name, default: "root"
 :password           password for user, default: randomly generated hash
-:image              Linux distribution, default: "Debian 8.1"
+:image              Linux distribution, default: "Debian 8"
 :data_center        data center, default: "Atlanta"
 :flavor             linode type/amount of RAM, default: "Linode 1024"
-:payment_terms      if you happen to have legacy default: 1
+:payment_terms      if you happen to have legacy, default: 1
 :kernel             Linux kernel, default: "Latest 64 bit"
 :private_key_path   Location of your private key file, default: "~/.ssh/id_rsa"
 :public_key_path    Location of your public key file, default: "~/.ssh/id_rsa.pub"
@@ -65,7 +75,7 @@ then you're ready to run `kitchen test` or `kitchen converge`
 ```
 $ kitchen test
 ```
-If you want to create a second yaml config; one for using Vagrant locally but a second to use the Linode driver when run on your CI server, create a config with a name like `.kitchen-ci.yml`:
+If you want to create a second yaml config; one for using Vagrant locally but another to use the Linode driver when run on your CI server, create a config with a name like `.kitchen-ci.yml`:
 ```
 ---
 driver:
@@ -89,9 +99,9 @@ Then you can run the second config by changing the KITCHEN_YAML environment vari
 ```
 $ KITCHEN_YAML="./.kitchen-ci.yml" kitchen test
 ```
-If you want to change any of the default settings, you can do it in the 'platforms' area:
+If you want to change any of the default settings, you can do so in the 'platforms' area:
 ```
-...
+...<snip>...
 platforms:
   - name: debian_jessie
     driver:
@@ -99,25 +109,9 @@ platforms:
       data_center: Dallas
       kernel: 4.0.2-x86_64-linode56
       image: Debian 7
-...
+...<snip>...
 ```
 
-### <a name="config-require-chef-omnibus"></a> require\_chef\_omnibus
-
-Determines whether or not a Chef [Omnibus package][chef_omnibus_dl] will be
-installed. There are several different behaviors available:
-
-* `true` - the latest release will be installed. Subsequent converges
-  will skip re-installing if chef is present.
-* `latest` - the latest release will be installed. Subsequent converges
-  will always re-install even if chef is present.
-* `<VERSION_STRING>` (ex: `10.24.0`) - the desired version string will
-  be passed the the install.sh script. Subsequent converges will skip if
-  the installed version and the desired version match.
-* `false` or `nil` - no chef is installed.
-
-The default value is unset, or `nil`.
-
 ## <a name="development"></a> Development
 
 * Source hosted at [GitHub][repo]
@@ -147,4 +141,3 @@ Apache 2.0 (see [LICENSE][license])
 [license]:          https://github.com/ssplatt/kitchen-linode/blob/master/LICENSE
 [repo]:             https://github.com/ssplatt/kitchen-linode
 [driver_usage]:     http://docs.kitchen-ci.org/drivers/usage
-[chef_omnibus_dl]:  http://www.getchef.com/chef/install/

data/kitchen-linode.gemspec

@@ -23,4 +23,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake', '~> 10.4'
+  spec.add_development_dependency 'rspec', '~> 3.4'
+  spec.add_development_dependency 'codeclimate-test-reporter', '~> 0.5'
 end

data/lib/kitchen/driver/linode.rb

@@ -32,29 +32,36 @@ module Kitchen
       
       default_config :username, 'root'
       default_config :password, nil
+      default_config :server_name, nil
       default_config :image, 140
       default_config :data_center, 4
       default_config :flavor, 1
       default_config :payment_terms, 1
-      default_config :ssh_key_name, nil
       default_config :kernel, 138
       
       default_config :sudo, true
-      default_config :port, 22
       default_config :ssh_timeout, 600
       
-      default_config :private_key, nil
-      default_config :private_key_path, "~/.ssh/id_rsa"
-      default_config :public_key, nil
-      default_config :public_key_path, "~/.ssh/id_rsa.pub"
+      default_config :private_key_path do
+        %w(id_rsa).map do |k|
+          f = File.expand_path("~/.ssh/#{k}")
+          f if File.exist?(f)
+        end.compact.first
+      end
+      default_config :public_key_path do |driver|
+        driver[:private_key_path] + '.pub' if driver[:private_key_path]
+      end
       
       default_config :api_key, ENV['LINODE_API_KEY']
       
       required_config :api_key
+      required_config :private_key_path
+      required_config :public_key_path
 
       def create(state)
         # create and boot server
         config_server_name
+        set_password
         
         if state[:server_id]
           info "#{config[:server_name]} (#{state[:server_id]}) already exists."
@@ -72,7 +79,7 @@ module Kitchen
         info("Waiting for linode to boot...")
         server.wait_for { ready? }
         info("Linode <#{state[:server_id]}, #{state[:hostname]}> ready.")
-        setup_ssh(server, state) if bourne_shell?
+        setup_ssh(state) if bourne_shell?
       rescue Fog::Errors::Error, Excon::Errors::Error => ex
         raise ActionFailed, ex.message
       end
@@ -94,26 +101,21 @@ module Kitchen
         Fog::Compute.new(:provider => 'Linode', :linode_api_key => config[:api_key])
       end
       
-      def create_server
-        if config[:password].nil?
-          config[:password] = [*('a'..'z'),*('A'..'Z'),*('0'..'9')].shuffle[0,20].join
-        end
-        
-        # set datacenter
+      def get_dc
         if config[:data_center].is_a? Integer
           data_center = compute.data_centers.find { |dc| dc.id == config[:data_center] }
         else
-          data_center = compute.data_centers.find { |dc| dc.location == config[:data_center] }
-          if data_center.nil?
-            data_center = compute.data_centers.find { |dc| dc.location =~ /#{config[:data_center]}/ }
-          end
+          data_center = compute.data_centers.find { |dc| dc.location =~ /#{config[:data_center]}/ }
         end
+        
         if data_center.nil?
           fail(UserError, "No match for data_center: #{config[:data_center]}")
         end
         info "Got data center: #{data_center.location}..."
-        
-        # set flavor
+        return data_center
+      end
+      
+      def get_flavor
         if config[:flavor].is_a? Integer
           if config[:flavor] < 1024
             flavor = compute.flavors.find { |f| f.id == config[:flavor] }
@@ -121,51 +123,48 @@ module Kitchen
             flavor = compute.flavors.find { |f| f.ram == config[:flavor] }
           end
         else
-          flavor = compute.flavors.find { |f| f.name == config[:flavor] }
-          if flavor.nil?
-            flavor = compute.flavors.find { |f| f.name =~ /#{config[:flavor]}/ }
-          end
+          flavor = compute.flavors.find { |f| f.name =~ /#{config[:flavor]}/ }
         end
+        
         if flavor.nil?
           fail(UserError, "No match for flavor: #{config[:flavor]}")
         end
         info "Got flavor: #{flavor.name}..."
-        
-        # set image/distribution
+        return flavor
+      end
+      
+      def get_image
         if config[:image].is_a? Integer
           image = compute.images.find { |i| i.id == config[:image] }
         else
-          image = compute.images.find { |i| i.name == config[:image] }
-          if image.nil?
-            image = compute.images.find { |i| i.name =~ /#{config[:image]}/ }
-          end
+          image = compute.images.find { |i| i.name =~ /#{config[:image]}/ }
         end
         if image.nil?
           fail(UserError, "No match for image: #{config[:image]}")
         end
         info "Got image: #{image.name}..."
-        
-        # set kernel
+        return image
+      end
+      
+      def get_kernel
         if config[:kernel].is_a? Integer
           kernel = compute.kernels.find { |k| k.id == config[:kernel] }
         else
-          kernel = compute.kernels.find { |k| k.name == config[:kernel] }
-          if kernel.nil?
-            kernel = compute.kernels.find { |k| k.name =~ /#{config[:kernel]}/ }
-          end
+          kernel = compute.kernels.find { |k| k.name =~ /#{config[:kernel]}/ }
         end
         if kernel.nil?
           fail(UserError, "No match for kernel: #{config[:kernel]}")
         end
         info "Got kernel: #{kernel.name}..."
+        return kernel
+      end
+      
+      def create_server
+        data_center = get_dc
+        flavor = get_flavor
+        image = get_image
+        kernel = get_kernel
         
-        if config[:private_key_path]
-          config[:private_key_path] = File.expand_path(config[:private_key_path])
-        end
-        if config[:public_key_path]
-          config[:public_key_path] = File.expand_path(config[:public_key_path])
-        end
-
         # submit new linode request
         compute.servers.create(
           :data_center => data_center,
@@ -179,7 +178,8 @@ module Kitchen
         )
       end
       
-      def setup_ssh(server, state)
+      def setup_ssh(state)
+        set_ssh_keys
         state[:ssh_key] = config[:private_key_path]
         do_ssh_setup(state, config)
       end
@@ -220,6 +220,23 @@ module Kitchen
         return if config[:server_name]
         config[:server_name] = "kitchen_linode-#{rand.to_s.split('.')[1]}"
       end
+      
+      # ensure a password is set
+      def set_password
+        if config[:password].nil?
+          config[:password] = [*('a'..'z'),*('A'..'Z'),*('0'..'9')].sample(15).join
+        end
+      end
+      
+      # set ssh keys
+      def set_ssh_keys
+        if config[:private_key_path]
+          config[:private_key_path] = File.expand_path(config[:private_key_path])
+        end
+        if config[:public_key_path]
+          config[:public_key_path] = File.expand_path(config[:public_key_path])
+        end
+      end
     end
   end
 end

data/lib/kitchen/driver/linode_version.rb

@@ -20,6 +20,6 @@ module Kitchen
 
   module Driver
     # Version string for Linode Kitchen driver
-    LINODE_VERSION = "0.10.0"
+    LINODE_VERSION = "0.11.0"
   end
 end

data/spec/kitchen/driver/linode_spec.rb

@@ -0,0 +1,170 @@
+# Encoding: UTF-8
+
+require_relative '../../spec_helper'
+require_relative '../../../lib/kitchen/driver/linode'
+
+require 'logger'
+require 'stringio'
+require 'rspec'
+require 'kitchen'
+require 'kitchen/driver/linode'
+require 'kitchen/provisioner/dummy'
+require 'kitchen/transport/dummy'
+require 'kitchen/verifier/dummy'
+require 'fog'
+
+describe Kitchen::Driver::Linode do
+  let(:logged_output) { StringIO.new }
+  let(:logger) { Logger.new(logged_output) }
+  let(:config) { Hash.new }
+  let(:state) { Hash.new }
+  let(:rsa) { File.expand_path('~/.ssh/id_rsa') }
+  let(:instance_name) { 'the_thing' }
+  let(:transport)     { Kitchen::Transport::Dummy.new }
+  let(:platform)      { Kitchen::Platform.new(name: 'fake_platform') }
+  let(:driver)        { Kitchen::Driver::Linode.new(config) }
+
+  let(:instance) do
+    double(
+      name: instance_name,
+      transport: transport,
+      logger: logger,
+      platform: platform,
+      to_str: 'instance'
+    )
+  end
+
+  let(:driver) { described_class.new(config) }
+
+  before(:each) do
+    allow_any_instance_of(described_class).to receive(:instance)
+      .and_return(instance)
+    allow(File).to receive(:exist?).and_call_original
+    allow(File).to receive(:exist?).with(rsa).and_return(true)
+  end
+  
+  describe '#finalize_config' do
+    before(:each) { allow(File).to receive(:exist?).and_return(false) }
+
+    context 'both private and public key info provided' do
+      let(:config) do
+        { private_key_path: '/tmp/key', public_key_path: '/tmp/key.pub' }
+      end
+
+      it 'raises no error' do
+        expect(driver.finalize_config!(instance)).to be
+      end
+    end
+  end
+
+  describe '#initialize' do
+    context 'default options' do
+      context 'only a RSA SSH key available for the user' do
+        before(:each) do
+          allow(File).to receive(:exist?).and_return(false)
+          allow(File).to receive(:exist?).with(rsa).and_return(true)
+        end
+
+        it 'uses the local user\'s RSA private key' do
+          expect(driver[:private_key_path]).to eq(rsa)
+        end
+
+        it 'uses the local user\'s RSA public key' do
+          expect(driver[:public_key_path]).to eq(rsa + '.pub')
+        end
+      end
+      
+      nils = [
+        :server_name,
+        :password
+      ]
+      nils.each do |i|
+        it "defaults to no #{i}" do
+          expect(driver[i]).to eq(nil)
+        end
+      end
+      
+    end
+    context 'overridden options' do
+      let(:config) do
+        {
+          image: 139,
+          data_center: 10,
+          flavor: 2,
+          kernel: 215,
+          username: 'someuser',
+          server_name: 'thisserver',
+          private_key_path: '/path/to/id_rsa',
+          public_key_path: '/path/to/id_rsa.pub',
+          password: 'somepassword'
+        }
+      end
+
+      it 'uses all the overridden options' do
+        drv = driver
+        config.each do |k, v|
+          expect(drv[k]).to eq(v)
+        end
+      end
+
+      it 'overrides server name prefix with explicit server name, if given' do
+        expect(driver[:server_name]).to eq(config[:server_name])
+      end
+    end
+  end
+  
+  describe '#create' do
+    let(:server) do
+      double(id: 'test123', wait_for: true, public_ip_address: %w(1.2.3.4))
+    end
+    let(:driver) do
+      d = super()
+      allow(d).to receive(:create_server).and_return(server)
+      allow(d).to receive(:do_ssh_setup).and_return(true)
+      d
+    end
+
+    context 'when a server is already created' do
+      it 'does not create a new instance' do
+        state[:server_id] = '1'
+        expect(driver).not_to receive(:create_server)
+        driver.create(state)
+      end
+    end
+
+    context 'required options provided' do
+      let(:config) do
+        {
+          username: 'someuser',
+          api_key: 'somekey',
+          disable_ssl_validation: false
+        }
+      end
+      let(:server) do
+        double(id: 'test123', wait_for: true, public_ip_address: %w(1.2.3.4))
+      end
+
+      let(:driver) do
+        d = described_class.new(config)
+        allow(d).to receive(:create_server).and_return(server)
+        allow(server).to receive(:id).and_return('test123')
+
+        allow(server).to receive(:wait_for)
+          .with(an_instance_of(Fixnum)).and_yield
+        allow(d).to receive(:bourne_shell?).and_return(false)
+        d
+      end
+
+      it 'returns nil, but modifies the state' do
+        expect(driver.send(:create, state)).to eq(nil)
+        expect(state[:server_id]).to eq('test123')
+      end
+
+      it 'throws an Action error when trying to create_server' do
+        allow(driver).to receive(:create_server).and_raise(Fog::Errors::Error)
+        expect { driver.send(:create, state) }.to raise_error(Kitchen::ActionFailed)
+      end
+    end
+  end
+
+end