kitchen-fog 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6b40bf2e82fa79545da6b55c68430f7578a83557
+  data.tar.gz: 8cd22ed93fbe59e67fb76da948685ccb56c03767
+SHA512:
+  metadata.gz: bdfe511e6a307c5e56217dca30c88f082498ea9eb0cf36b36761cb0104650696c23ab3caae9a9448f2472c64719883486ef4df6979ac402d1644603c7b0e7149
+  data.tar.gz: 5c21fa33874143f44585b3801ab8cf84d105be44adca84c9eff6012dd94777a8c4a01ab46e2a393a8cfc521f45813e988f445f70c6d46e8dfa4dce0b795f8e6e

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.kitchen
+*.sw?
+*~

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+
+gemfile:
+  - Gemfile
+
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+
+# vim: ai et ts=2 sts=2 sw=2 ft=yaml

data/CHANGELOG.md

@@ -0,0 +1,53 @@
+# 0.2.0 / 2013-10-02
+
+### New Features
+
+* Generalize kitchen-openstack to work with other providers
+
+### Improvements
+
+* PR [#19][] - Don't assume `public` and `private` network names exist
+* PR [#19][] - Make IPv4 or IPv6 configurable instead of relying on Fog to pick
+
+### Bug Fixes
+
+* PR [#20][] - Limit generated hostnames to 64 characters
+
+# 0.4.0 / 2013-06-06
+
+### New Features
+
+* PR [#12][] - Support `openstack_network_name` option; via [@saketoba][]
+* PR [#11][] - Support `ssh_key` option; via [@saketoba][]
+
+# 0.2.0 / 2013-05-11
+
+### Bug Fixes
+
+* PR [#7][] - `disable_ssl_validation` wasn't being respected on destroy
+
+### New Features
+
+* PR [#10][] - Support optional `openstack_region` and `openstack_service_name`
+* PR [#2][] - Support `key_name:` option; via [@stevendanna][]
+
+### Improvements
+
+* PR [#7][] - Clean up/refactor to pass style checks
+* PR [#9][] - Add some (probably overkill) RSpec tests
+
+# 0.1.0 / 2013-03-12
+
+* Initial release! Woo!
+
+[#20]: https://github.com/RoboticCheese/kitchen-openstack/pull/20
+[#19]: https://github.com/RoboticCheese/kitchen-openstack/pull/19
+[#12]: https://github.com/RoboticCheese/kitchen-openstack/pull/12
+[#11]: https://github.com/RoboticCheese/kitchen-openstack/pull/11
+[#10]: https://github.com/RoboticCheese/kitchen-openstack/pull/10
+[#9]: https://github.com/RoboticCheese/kitchen-openstack/pull/9
+[#7]: https://github.com/RoboticCheese/kitchen-openstack/pull/7
+[#2]: https://github.com/RoboticCheese/kitchen-openstack/pull/2
+
+[@saketoba]: https://github.com/saketoba
+[@stevendanna]: https://github.com/stevendanna

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kitchen-fog.gemspec
+gemspec
+
+# vim: ai et ts=2 sts=2 sw=2 ft=ruby

data/LICENSE.txt

@@ -0,0 +1,15 @@
+Author:: Jonathan Hartman (<j@p4nt5.com>)
+
+Copyright (c) 2013 Jonathan Hartman
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,71 @@
+[![Build Status](https://travis-ci.org/TerryHowe/kitchen-fog.png?branch=master)](https://travis-ci.org/TerryHowe/kitchen-fog) [![Code Climate](https://codeclimate.com/github/TerryHowe/kitchen-fog.png)](https://codeclimate.com/github/TerryHowe/kitchen-fog)
+
+# Kitchen::Fog
+
+A Fog Nova driver for Test Kitchen 1.0!
+
+Generalized from [Jonathan Hartman](https://github.com/RoboticCheese)'s awesome work on an [OpenStack driver](https://github.com/RoboticCheese/kitchen-openstack) which is shamelessly copied from [Fletcher Nichol](https://github.com/fnichol)'s
+awesome work on an [EC2 driver](https://github.com/opscode/kitchen-ec2).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'kitchen-fog'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kitchen-fog
+
+## Usage
+
+Provide, at a minimum, the required driver options in your `.kitchen.yml` file.  The authentication and server_create sections are specific to the provider:
+
+    driver_plugin: fog
+    driver_config:
+      authentication:
+        provider: 'hp'
+        hp_access_key: 'username'
+        hp_secret_key: 'password'
+        hp_auth_uri: 'https://region-a.geo-1.identity.hpcloudsvc.com:35357/v2.0/tokens'
+        hp_tenant_id: 'project/tenant id'
+        hp_avl_zone: 'region-b.geo-1'
+        version: v2
+        hp_use_upass_auth_style: true
+      server_create:
+        flavor_id: '103'
+        image_id: '8c096c29-a666-4b82-99c4-c77dc70cfb40'
+        networks: [ '76abe0b1-581a-4698-b200-a2e890f4eb8d' ]
+      network: '76abe0b1-581a-4698-b200-a2e890f4eb8d'
+      require_chef_omnibus: latest (if you'll be using Chef)
+
+By default, a unique server name will be generated and the current user's SSH
+key will be used, though that behavior can be overridden with additional
+options:
+
+    name: [A UNIQUE SERVER NAME]
+    ssh_key: [PATH TO YOUR PRIVATE SSH KEY]
+    public_key_path: [PATH TO YOUR SSH PUBLIC KEY]
+    username: [SSH USER]
+    port: [SSH PORT]
+    key_name: [SSH KEY NAME]
+
+If a key\_name is provided it will be used instead of any
+public\_key\_path that is specified.
+
+    disable_ssl_validation: true
+
+Only disable SSL cert validation if you absolutely know what you are doing,
+but are stuck with a deployment without valid SSL certs.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,25 @@
+require 'bundler/gem_tasks'
+require 'tailor/rake_task'
+require 'cane/rake_task'
+require 'rspec/core/rake_task'
+
+desc 'Run Cane to check quality metrics'
+Cane::RakeTask.new
+
+desc 'Run Tailor to lint check code'
+Tailor::RakeTask.new do |task|
+  task.file_set '**/**/*.rb'
+end
+
+desc 'Display LOC stats'
+task :loc do
+  puts "\n## LOC Stats"
+  sh 'countloc -r lib/kitchen'
+end
+
+desc 'Run RSpec unit tests'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => [ :cane, :tailor, :loc, :spec ]
+
+# vim: ai et ts=2 sts=2 sw=2 ft=ruby

data/kitchen-fog.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kitchen/driver/fog_version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'kitchen-fog'
+  spec.version       = Kitchen::Driver::FOG_VERSION
+  spec.authors       = ['Jonathan Hartman']
+  spec.email         = ['j@p4nt5.com']
+  spec.description   = %q{A Test Kitchen Fog Nova driver}
+  spec.summary       = spec.description
+  spec.homepage      = 'https://github.com/TerryHowe/kitchen-fog'
+  spec.license       = 'Apache'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'test-kitchen', '~> 1.0.0.beta'
+  spec.add_dependency 'fog', '~> 1.15'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'tailor'
+  spec.add_development_dependency 'cane'
+  spec.add_development_dependency 'countloc'
+  spec.add_development_dependency 'rspec'
+end
+
+# vim: ai et ts=2 sts=2 sw=2 ft=ruby

data/lib/kitchen/driver/fog.rb

@@ -0,0 +1,169 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Jonathan Hartman (<j@p4nt5.com>)
+#
+# Copyright (C) 2013, Jonathan Hartman
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'benchmark'
+require 'fog'
+require 'kitchen'
+require 'etc'
+require 'ipaddr'
+require 'socket'
+
+module Kitchen
+  module Driver
+    # Fog driver for Kitchen.
+    #
+    # @author Jonathan Hartman <j@p4nt5.com>
+    class Fog < Kitchen::Driver::SSHBase
+      default_config :name, nil
+      default_config :public_key_path, File.expand_path('~/.ssh/id_dsa.pub')
+      default_config :username, 'root'
+      default_config :port, '22'
+      default_config :use_ipv6, false
+      default_config :network_name, nil
+
+      def create(state)
+        config[:name] ||= generate_name(instance.name)
+        config[:disable_ssl_validation] and disable_ssl_validation
+        server = create_server(state)
+        unless config[:floating_ip_create].nil?
+          create_floating_ip(server)
+        else
+          state[:hostname] = get_ip(server)
+        end
+        wait_for_sshd(state[:hostname]) ; puts '(ssh ready)'
+        unless config[:ssh_key] or config[:key_name]
+          do_ssh_setup(state, config, server)
+        end
+      rescue ::Fog::Errors::Error, Excon::Errors::Error => ex
+        raise ActionFailed, ex.message
+      end
+
+      def destroy(state)
+        return if state[:server_id].nil?
+
+        config[:disable_ssl_validation] and disable_ssl_validation
+        server = compute.servers.get(state[:server_id])
+        server.destroy unless server.nil?
+        info "Fog instance <#{state[:server_id]}> destroyed."
+        state.delete(:server_id)
+        state.delete(:hostname)
+      end
+
+      private
+
+      def compute
+        ::Fog::Compute.new(config[:authentication].dup)
+      end
+
+      def network
+        authentication = config[:authentication].dup
+        authentication.delete(:version)
+        ::Fog::Network.new(authentication)
+      end
+
+      def create_server(state)
+        server_def = config[:server_create] || {}
+        server_def = server_def.dup
+        server_def[:name] = config[:name]
+        # Can't use the Fog bootstrap and/or setup methods here; they require a
+        # public IP address that can't be guaranteed to exist across all
+        # OpenStack deployments (e.g. TryStack ARM only has private IPs).
+        server = compute.servers.create(server_def)
+        state[:server_id] = server.id
+        info "Fog instance <#{state[:server_id]}> created."
+        server.wait_for { print '.'; ready? } ; puts "\n(server ready)"
+        server
+      end
+
+      def create_floating_ip(server)
+        hsh = config[:floating_ip_create].dup
+        floater = network.create_floating_ip(hsh[:floating_network_id], hsh)
+        floating_id = floater.body['floatingip']['id']
+        state[:hostname] = floater.body['floatingip']['floating_ip_address']
+        port = network.ports(:filters => { :device_id => server.id }).first
+        network.associate_floating_ip(floating_id, port.id)
+      end
+
+      def generate_name(base)
+        # Generate what should be a unique server name
+        sep = '-'
+        pieces = [
+          base,
+          Etc.getlogin,
+          Socket.gethostname,
+          Array.new(8) { rand(36).to_s(36) }.join
+        ]
+        until pieces.join(sep).length <= 64 do
+          if pieces[2].length > 24
+            pieces[2] = pieces[2][0..-2]
+          elsif pieces[1].length > 16
+            pieces[1] = pieces[1][0..-2]
+          elsif pieces[0].length > 16
+            pieces[0] = pieces[0][0..-2]
+          end
+        end
+        pieces.join sep
+      end
+
+      def get_ip(server)
+        if config[:network_name]
+          debug "Using configured network: #{config[:network_name]}"
+          return server.addresses[config[:network_name]].first['addr']
+        end
+        begin
+          pub, priv = server.public_ip_addresses, server.private_ip_addresses
+        rescue Exception => e
+          # See Fog issue: https://github.com/fog/fog/issues/2160
+          addrs = server.addresses
+          addrs['public'] and pub = addrs['public'].map { |i| i['addr'] }
+          addrs['private'] and priv = addrs['private'].map { |i| i['addr'] }
+        end
+        pub, priv = parse_ips(pub, priv)
+        pub.first || priv.first || raise(ActionFailed, 'Could not find an IP')
+      end
+
+      def parse_ips(pub, priv)
+        pub, priv = Array(pub), Array(priv)
+        if config[:use_ipv6]
+          [pub, priv].each { |n| n.select! { |i| IPAddr.new(i).ipv6? } }
+        else
+          [pub, priv].each { |n| n.select! { |i| IPAddr.new(i).ipv4? } }
+        end
+        return pub, priv
+      end
+
+      def do_ssh_setup(state, config, server)
+        ssh = ::Fog::SSH.new(state[:hostname], config[:username],
+          { :password => server.password })
+        pub_key = open(config[:public_key_path]).read
+        ssh.run([
+          %{mkdir .ssh},
+          %{echo "#{pub_key}" >> ~/.ssh/authorized_keys},
+          %{passwd -l #{config[:username]}}
+        ])
+      end
+
+      def disable_ssl_validation
+        require 'excon'
+        Excon.defaults[:ssl_verify_peer] = false
+      end
+    end
+  end
+end
+
+# vim: ai et ts=2 sts=2 sw=2 ft=ruby

data/lib/kitchen/driver/fog_version.rb

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Jonathan Hartman (<j@p4nt5.com>)
+#
+# Copyright (C) 2013, Jonathan Hartman
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Kitchen
+  module Driver
+    # Version string for Fog Kitchen driver
+    FOG_VERSION = '0.6.0'
+  end
+end
+
+# vim: ai et ts=2 sts=2 sw=2 ft=ruby

data/spec/kitchen/driver/openstack_spec.rb

@@ -0,0 +1,593 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Jonathan Hartman (<j@p4nt5.com>)
+#
+# Copyright (C) 2013, Jonathan Hartman
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'logger'
+require 'stringio'
+require 'rspec'
+require 'kitchen'
+require_relative '../../spec_helper'
+
+describe Kitchen::Driver::Fog do
+  let(:logged_output) { StringIO.new }
+  let(:logger) { Logger.new(logged_output) }
+  let(:config) { Hash.new }
+  let(:state) { Hash.new }
+
+  let(:instance) do
+    double(:name => 'potatoes', :logger => logger, :to_str => 'instance')
+  end
+
+  let(:driver) do
+    d = Kitchen::Driver::Fog.new(config)
+    d.instance = instance
+    d
+  end
+
+  describe '#initialize'do
+    context 'default options' do
+      it 'defaults to no name' do
+        expect(driver[:name]).to eq(nil)
+      end
+
+      it 'defaults to local user\'s SSH public key' do
+        expect(driver[:public_key_path]).to eq(File.expand_path(
+          '~/.ssh/id_dsa.pub'))
+      end
+
+      it 'defaults to SSH with root user on port 22' do
+        expect(driver[:username]).to eq('root')
+        expect(driver[:port]).to eq('22')
+      end
+
+      it 'defaults to use ipv4' do
+        expect(driver[:use_ipv6]).to eq(false)
+      end
+
+      it 'defaults to no network name' do
+        expect(driver[:network_name]).to eq(nil)
+      end
+    end
+
+    context 'overridden options' do
+      let(:config) do
+        {
+          :authentication => {
+            :openstack_tenant => 'that_one',
+            :openstack_region => 'atlantis',
+            :openstack_service_name => 'the_service',
+          },
+          :server_create => {
+            :image_ref => '22',
+            :flavor_ref => '33',
+          },
+          :public_key_path => '/tmp',
+          :username => 'admin',
+          :port => '2222',
+          :name => 'puppy',
+          :ssh_key => '/path/to/id_rsa'
+        }
+      end
+
+      it 'uses all the overridden options' do
+        drv = driver
+        config.each do |k, v|
+          expect(drv[k]).to eq(v)
+        end
+      end
+
+      it 'SSH with user-specified private key' do
+        expect(driver[:ssh_key]).to eq('/path/to/id_rsa')
+      end
+    end
+  end
+
+  describe '#create' do
+    let(:server) do
+      double(:id => 'test123', :wait_for => true,
+        :public_ip_addresses => %w{1.2.3.4})
+    end
+    let(:driver) do
+      d = Kitchen::Driver::Fog.new(config)
+      d.instance = instance
+      d.stub(:generate_name).with('potatoes').and_return('a_monkey!')
+      d.stub(:create_server).and_return(server)
+      d.stub(:wait_for_sshd).with('1.2.3.4').and_return(true)
+      d.stub(:get_ip).and_return('1.2.3.4')
+      d.stub(:do_ssh_setup).and_return(true)
+      d
+    end
+
+    context 'required options provided' do
+      let(:config) do
+        {
+          :authentication => {
+            :openstack_username => 'hello',
+            :openstack_api_key => 'world',
+            :openstack_auth_url => 'http:',
+            :openstack_tenant => 'www'
+          },
+          :server_create => {
+            :flavorRef => 101,
+            :imageRef => 222
+          }
+        }
+      end
+
+      it 'generates a server name in the absence of one' do
+        driver.create(state)
+        expect(driver[:name]).to eq('a_monkey!')
+      end
+
+      it 'gets a proper hostname (IP)' do
+        driver.create(state)
+        expect(state[:hostname]).to eq('1.2.3.4')
+      end
+
+      it 'does not disable SSL validation' do
+        driver.should_not_receive(:disable_ssl_validation)
+        driver.create(state)
+      end
+    end
+
+    context 'SSL validation disabled' do
+      let(:config) { { :disable_ssl_validation => true } }
+
+      it 'disables SSL cert validation' do
+        driver.should_receive(:disable_ssl_validation)
+        driver.create(state)
+      end
+    end
+  end
+
+  describe '#destroy' do
+    let(:server_id) { '12345' }
+    let(:hostname) { 'example.com' }
+    let(:state) { { :server_id => server_id, :hostname => hostname } }
+    let(:server) { double(:nil? => false, :destroy => true) }
+    let(:servers) { double(:get => server) }
+    let(:compute) { double(:servers => servers) }
+
+    let(:driver) do
+      d = Kitchen::Driver::Fog.new(config)
+      d.instance = instance
+      d.stub(:compute).and_return(compute)
+      d
+    end
+
+    context 'a live server that needs to be destroyed' do
+      it 'destroys the server' do
+        state.should_receive(:delete).with(:server_id)
+        state.should_receive(:delete).with(:hostname)
+        driver.destroy(state)
+      end
+
+      it 'does not disable SSL cert validation' do
+        driver.should_not_receive(:disable_ssl_validation)
+        driver.destroy(state)
+      end
+    end
+
+    context 'no server ID present' do
+      let(:state) { Hash.new }
+
+      it 'does nothing' do
+        driver.stub(:compute)
+        driver.should_not_receive(:compute)
+        state.should_not_receive(:delete)
+        driver.destroy(state)
+      end
+    end
+
+    context 'a server that was already destroyed' do
+      let(:servers) do
+        s = double('servers')
+        s.stub(:get).with('12345').and_return(nil)
+        s
+      end
+      let(:compute) { double(:servers => servers) }
+      let(:driver) do
+        d = Kitchen::Driver::Fog.new(config)
+        d.instance = instance
+        d.stub(:compute).and_return(compute)
+        d
+      end
+
+      it 'does not try to destroy the server again' do
+        allow_message_expectations_on_nil
+        driver.destroy(state)
+      end
+    end
+
+    context 'SSL validation disabled' do
+      let(:config) { { :disable_ssl_validation => true } }
+
+      it 'disables SSL cert validation' do
+        driver.should_receive(:disable_ssl_validation)
+        driver.destroy(state)
+      end
+    end
+  end
+
+  describe '#compute' do
+    let(:config) do
+      {
+        :authentication => {
+          :openstack_username => 'monkey',
+          :openstack_api_key => 'potato',
+          :openstack_auth_url => 'http:',
+          :openstack_tenant => 'link',
+          :openstack_region => 'ord',
+          :openstack_service_name => 'the_service'
+        }
+      }
+    end
+
+    context 'all requirements provided' do
+      it 'creates a new compute connection' do
+        Fog::Compute.stub(:new) { |arg| arg }
+        res = config.merge({ :provider => 'fog' })
+        expect(driver.send(:compute)).to eq(res[:authentication])
+      end
+    end
+
+    context 'only an API key provided' do
+      let(:config) { { :authentication => { :openstack_api_key => '1234' } } }
+
+      it 'raises an error' do
+        expect { driver.send(:compute) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'only a username provided' do
+      let(:config) do
+        { :authentication => { :openstack_username => 'monkey' } }
+      end
+
+      it 'raises an error' do
+        expect { driver.send(:compute) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#create_server' do
+    let(:config) do
+      {
+        :name => 'hello',
+        :image_ref => 'there',
+        :flavor_ref => 'captain',
+        :public_key_path => 'tarpals'
+      }
+    end
+    let(:server) do
+      double(:id => 'test222', :wait_for => true,
+        :public_ip_addresses => %w{1.2.3.4})
+    end
+    let(:servers) do
+      s = double('servers')
+      s.stub(:create).and_return(server)
+      s
+    end
+    let(:compute) { double(:servers => servers) }
+    let(:driver) do
+      d = Kitchen::Driver::Fog.new(config)
+      d.instance = instance
+      d.stub(:compute).and_return(compute)
+      d
+    end
+
+    context 'a default config' do
+      before(:each) { @config = config.dup }
+
+      it 'creates the server using a compute connection' do
+        state = {}
+        expect(driver.send(:create_server, state)).to eq(server)
+        expect(state).to eq({ :server_id => 'test222' })
+      end
+    end
+
+    context 'a provided public key path' do
+      let(:config) do
+        {
+          :name => 'hello',
+          :image_ref => 'there',
+          :flavor_ref => 'captain',
+          :public_key_path => 'tarpals'
+        }
+      end
+      before(:each) { @config = config.dup }
+
+      it 'passes that public key path to Fog' do
+        state = {}
+        expect(driver.send(:create_server, state)).to eq(server)
+        expect(state).to eq({ :server_id => 'test222' })
+      end
+    end
+
+    context 'a provided key name' do
+      let(:config) do
+        {
+          :name => 'hello',
+          :image_ref => 'there',
+          :flavor_ref => 'captain',
+          :public_key_path => 'montgomery',
+          :key_name => 'tarpals'
+        }
+      end
+      before(:each) { @config = config.dup }
+
+      it 'passes that key name to Fog' do
+        state = {}
+        expect(driver.send(:create_server, state)).to eq(server)
+        expect(state).to eq({ :server_id => 'test222' })
+      end
+    end
+  end
+
+  describe '#generate_name' do
+    before(:each) do
+      Etc.stub(:getlogin).and_return('user')
+      Socket.stub(:gethostname).and_return('host')
+    end
+
+    it 'generates a name' do
+      expect(driver.send(:generate_name, 'monkey')).to match(
+        /^monkey-user-host-/)
+    end
+
+    context 'local node with a long hostname' do
+      before(:each) do
+        Socket.unstub(:gethostname)
+        Socket.stub(:gethostname).and_return('ab.c' * 20)
+      end
+
+      it 'limits the generated name to 64-characters' do
+        expect(driver.send(:generate_name, 'long').length).to eq(64)
+      end
+    end
+  end
+
+  describe '#get_ip' do
+    let(:addresses) { nil }
+    let(:public_ip_addresses) { nil }
+    let(:private_ip_addresses) { nil }
+    let(:parsed_ips) { [[], []] }
+    let(:driver) do
+      d = Kitchen::Driver::Fog.new(config)
+      d.instance = instance
+      d.stub(:parse_ips).and_return(parsed_ips)
+      d
+    end
+    let(:server) do
+      double(:addresses => addresses,
+        :public_ip_addresses => public_ip_addresses,
+        :private_ip_addresses => private_ip_addresses)
+    end
+
+    context 'both public and private IPs' do
+      let(:public_ip_addresses) { %w{1::1 1.2.3.4} }
+      let(:private_ip_addresses) { %w{5.5.5.5} }
+      let(:parsed_ips) { [%w{1.2.3.4}, %w{5.5.5.5}] }
+
+      it 'returns a public IPv4 address' do
+        expect(driver.send(:get_ip, server)).to eq('1.2.3.4')
+      end
+    end
+
+    context 'only public IPs' do
+      let(:public_ip_addresses) { %w{4.3.2.1 2::1} }
+      let(:parsed_ips) { [%w{4.3.2.1}, []] }
+
+      it 'returns a public IPv4 address' do
+        expect(driver.send(:get_ip, server)).to eq('4.3.2.1')
+      end
+    end
+
+    context 'only private IPs' do
+      let(:private_ip_addresses) { %w{3::1 5.5.5.5} }
+      let(:parsed_ips) { [[], %w{5.5.5.5}] }
+
+      it 'returns a private IPv4 address' do
+        expect(driver.send(:get_ip, server)).to eq('5.5.5.5')
+      end
+    end
+
+    context 'IPs in user-defined network group' do
+      let(:config) { { :network_name => 'mynetwork' } }
+      let(:addresses) do
+        {
+          'mynetwork' => [
+            { 'addr' => '7.7.7.7' },
+            { 'addr' => '4::1' }
+          ]
+        }
+      end
+
+      it 'returns a IPv4 address in user-defined network group' do
+        expect(driver.send(:get_ip, server)).to eq('7.7.7.7')
+      end
+    end
+
+    context 'an Fog deployment without the floating IP extension' do
+      let(:server) do
+        s = double('server')
+        s.stub(:addresses).and_return(addresses)
+        s.stub(:public_ip_addresses).and_raise(
+          Fog::Compute::OpenStack::NotFound)
+        s.stub(:private_ip_addresses).and_raise(
+          Fog::Compute::OpenStack::NotFound)
+        s
+      end
+
+      context 'both public and private IPs in the addresses hash' do
+        let(:addresses) do
+          {
+            'public' => [{ 'addr' => '6.6.6.6' }, { 'addr' => '7.7.7.7' }],
+            'private' => [{ 'addr' => '8.8.8.8' }, { 'addr' => '9.9.9.9' }]
+          }
+        end
+        let(:parsed_ips) { [%w{6.6.6.6 7.7.7.7}, %w{8.8.8.8 9.9.9.9}] }
+
+        it 'selects the first public IP' do
+          expect(driver.send(:get_ip, server)).to eq('6.6.6.6')
+        end
+      end
+
+      context 'only public IPs in the address hash' do
+        let(:addresses) do
+          { 'public' => [{ 'addr' => '6.6.6.6' }, { 'addr' => '7.7.7.7' }] }
+        end
+        let(:parsed_ips) { [%w{6.6.6.6 7.7.7.7}, []] }
+
+        it 'selects the first public IP' do
+          expect(driver.send(:get_ip, server)).to eq('6.6.6.6')
+        end
+      end
+
+      context 'only private IPs in the address hash' do
+        let(:addresses) do
+          { 'private' => [{ 'addr' => '8.8.8.8' }, { 'addr' => '9.9.9.9' }] }
+        end
+        let(:parsed_ips) { [[], %w{8.8.8.8 9.9.9.9}] }
+
+        it 'selects the first private IP' do
+          expect(driver.send(:get_ip, server)).to eq('8.8.8.8')
+        end
+      end
+    end
+
+    context 'no IP addresses whatsoever' do
+      it 'raises an exception' do
+        expect { driver.send(:get_ip, server) }.to raise_error
+      end
+    end
+  end
+
+  describe '#parse_ips' do
+    let(:pub_v4) { %w{1.1.1.1 2.2.2.2} }
+    let(:pub_v6) { %w{1::1 2::2} }
+    let(:priv_v4) { %w{3.3.3.3 4.4.4.4} }
+    let(:priv_v6) { %w{3::3 4::4} }
+    let(:pub) { pub_v4 + pub_v6 }
+    let(:priv) { priv_v4 + priv_v6 }
+
+    context 'both public and private IPs' do
+      context 'IPv4 (default)' do
+        it 'returns only the v4 IPs' do
+          expect(driver.send(:parse_ips, pub, priv)).to eq([pub_v4, priv_v4])
+        end
+      end
+
+      context 'IPv6' do
+        let(:config) { { :use_ipv6 => true } }
+
+        it 'returns only the v6 IPs' do
+          expect(driver.send(:parse_ips, pub, priv)).to eq([pub_v6, priv_v6])
+        end
+      end
+    end
+
+    context 'only public IPs' do
+      let(:priv) { nil }
+
+      context 'IPv4 (default)' do
+        it 'returns only the v4 IPs' do
+          expect(driver.send(:parse_ips, pub, priv)).to eq([pub_v4, []])
+        end
+      end
+
+      context 'IPv6' do
+        let(:config) { { :use_ipv6 => true } }
+
+        it 'returns only the v6 IPs' do
+          expect(driver.send(:parse_ips, pub, priv)).to eq([pub_v6, []])
+        end
+      end
+    end
+
+    context 'only private IPs' do
+      let(:pub) { nil }
+
+      context 'IPv4 (default)' do
+        it 'returns only the v4 IPs' do
+          expect(driver.send(:parse_ips, pub, priv)).to eq([[], priv_v4])
+        end
+      end
+
+      context 'IPv6' do
+        let(:config) { { :use_ipv6 => true } }
+
+        it 'returns only the v6 IPs' do
+          expect(driver.send(:parse_ips, pub, priv)).to eq([[], priv_v6])
+        end
+      end
+    end
+
+    context 'no IPs whatsoever' do
+      let(:pub) { nil }
+      let(:priv) { nil }
+
+      context 'IPv4 (default)' do
+        it 'returns empty lists' do
+          expect(driver.send(:parse_ips, pub, priv)).to eq([[], []])
+        end
+      end
+
+      context 'IPv6' do
+        let(:config) { { :use_ipv6 => true } }
+
+        it 'returns empty lists' do
+          expect(driver.send(:parse_ips, nil, nil)).to eq([[], []])
+        end
+      end
+    end
+  end
+
+  describe '#do_ssh_setup' do
+    let(:server) { double(:password => 'aloha') }
+    let(:state) { { :hostname => 'host' } }
+    let(:read) { double(:read => 'a_key') }
+    let(:ssh) do
+      s = double('ssh')
+      s.stub(:run) { |args| args }
+      s
+    end
+
+    it 'opens an SSH session to the server' do
+      Fog::SSH.stub(:new).with('host', 'root',
+        { :password => 'aloha' }).and_return(ssh)
+      driver.stub(:open).with(File.expand_path(
+        '~/.ssh/id_dsa.pub')).and_return(read)
+      read.stub(:read).and_return('a_key')
+      res = driver.send(:do_ssh_setup, state, config, server)
+      expected = [
+        'mkdir .ssh',
+        'echo "a_key" >> ~/.ssh/authorized_keys',
+        'passwd -l root'
+      ]
+      expect(res).to eq(expected)
+    end
+  end
+
+  describe '#disable_ssl_validation' do
+    it 'turns off Excon SSL cert validation' do
+      expect(driver.send(:disable_ssl_validation)).to eq(false)
+    end
+  end
+end
+
+# vim: ai et ts=2 sts=2 sw=2 ft=ruby

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Jonathan Hartman (<j@p4nt5.com>)
+#
+# Copyright (C) 2013, Jonathan Hartman
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'rspec'
+require_relative '../lib/kitchen/driver/fog'
+
+# vim: ai et ts=2 sts=2 sw=2 ft=ruby

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: kitchen-fog
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Jonathan Hartman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-kitchen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tailor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: countloc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Test Kitchen Fog Nova driver
+email:
+- j@p4nt5.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- kitchen-fog.gemspec
+- lib/kitchen/driver/fog.rb
+- lib/kitchen/driver/fog_version.rb
+- spec/kitchen/driver/openstack_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/TerryHowe/kitchen-fog
+licenses:
+- Apache
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.5
+signing_key: 
+specification_version: 4
+summary: A Test Kitchen Fog Nova driver
+test_files:
+- spec/kitchen/driver/openstack_spec.rb
+- spec/spec_helper.rb