chef-provisioning-fog 0.15.3 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f8cd8c1afd5bad40b2fa6dd04e9637e96ad4928
-  data.tar.gz: f6bac8c8f71b733555689223288a9f1e9e18717b
+  metadata.gz: 4fe75ef2b7b47f463c63d139a34b263eacf4b900
+  data.tar.gz: d8f13c9f9302f33dc71e234ac8f6e3a830a60d40
 SHA512:
-  metadata.gz: 25aa7920e7fedc41467a0c9d92c632d8ba6ed6c1d9490e340a853302a82696d62ca506c4a17e77e917e6b03a58ee7d2c362433b0d5fdf8c9cdc6e426644bbc31
-  data.tar.gz: ca9c30842125ca5d5d609698d7a2d1d9323a19868d9973001ccb69a58600495852dfcbb33a38f938d9d38360bac5f56cd299e9dc0ed1fbdae5bcc03048dfd9c4
+  metadata.gz: 0da8a4fa982e2d900b5fe83537276c95112280646aa60ce279f7cc2004c82f90fa6b4a1284e3eeb475e0b26c551a0207f2a68e9e81956cdb6229b92815d122a8
+  data.tar.gz: b16b69e8db0bf1cac20bb1dcad8952d482ad4aadb56a3e7483088c687a909cbf0df7c67f47f7fe23772008d7eb68c8d46815da38a9d60edd1d6e530f95bd152b

data/README.md

@@ -19,15 +19,18 @@ These are the primary documents to help learn about using Provisioning and creat
 
 ## chef-provisioning-fog Usage and Examples
 
+**A note about key pairs** - The key name used in `fog_key_pair` must be the same as the filename of the local key to be used. If the key does not exist in one of `private_key_paths` (which you can set in knife.rb or in a client.rb) it will be created.
+
 ### DigitalOcean
 
-If you are on DigitalOcean and using the `tugboat` gem, you can do this:
+Update your knife.rb to contain your DigitalOcean API token and the driver
 
+```ruby
+driver 'fog:DigitalOcean'
+driver_options compute_options: { digitalocean_token: 'token' }
 ```
-$ gem install chef-provisioning-fog
-$ export CHEF_DRIVER=fog:DigitalOcean
-$ chef-client -z simple.rb
-```
+
+For a full example see [examples/digitalocean/simple.rb](examples/digitalocean/simple.rb).
 
 ### OpenStack
 
@@ -41,56 +44,7 @@ driver_options :compute_options => { :openstack_auth_url => 'http://YOUROPENSTAC
                                      :openstack_tenant   => 'YOURTENANTIDNAME' }
 ```
 
-How to install the gem, and run a `simple.rb`.
-
-```
-$ gem install chef-provisioning-fog
-$ chef-client -z simple.rb
-```
-
-And inside your recipe, you'll need something like the following. This specifically will create 3 dev-webservers, and 1 qa-webserver.
-
-```ruby
-require 'chef/provisioning'
-
-with_machine_options({
-                       :bootstrap_options => {
-                         :flavor_ref  => 3,
-                         :image_ref => 'my-fake-ubuntu-image-0c1f2c38432b',
-                         :nics => [{ :net_id => 'my-tenantnetwork-id-89afddb9db6c'}],
-                         :key_name => 'mykeyname',
-                         :floating_ip_pool => 'ext-net'
-                         },
-                       :ssh_username => 'ubuntu'
-                     })
-
-machine_batch 'dev' do
-  1.upto(3) do |n|
-    instance = "#{name}-webserver-#{n}"
-    machine instance do
-      role 'webserver'
-      tag "#{name}-webserver-#{n}"
-      converge true
-    end
-  end
-end
-
-machine 'qa-webserver' do
-  tag 'qabox'
-  machine_options({
-                    bootstrap_options: {
-                      :flavor_ref  => 3,
-                      :nics => [{ :net_id => 'my-tenantnetwork-id-89afddb9db6c'}],
-                      :key_name => 'jdizzle',
-                      :image_ref => 'my-centos-image-2b0b6bb7b0c12b0b6bb7b0c1',
-                      :floating_ip_pool => 'ext-net'
-                      },
-                    :ssh_username => 'centos'
-                  })
-  role 'webserver'
-  converge true
-end
-```
+For a full example see [examples/openstack/simple.rb](examples/openstack/simple.rb).
 
 ### Rackspace
 
@@ -106,42 +60,7 @@ You must configure some credentials and region in a `knife.rb` file like so:
   }
 ```
 
-Ensure your Gemfile has (or install these with `gem install`):
-```
-gem 'chef-provisioning'
-gem 'chef-provisioning-fog'
-```
-
-Then, here's an example of making a keypair and booting a server:
-```ruby
-require 'chef/provisioning'
-require 'chef/provisioning/fog_driver/recipe_dsl'
-
-# create/update a keypair at Rackspace's API endpoint, so we can use it later
-fog_key_pair 'example_id_rsa'
-
-# Options to bootstrap 2gb General instance with CentOS 6 (PVHVM)
-with_machine_options({
-  :bootstrap_options => {
-    :flavor_id => 'general1-2', # required
-    :image_id  => 'fabe045f-43f8-4991-9e6c-5cabd617538c', # required
-    :key_name  => 'example_id_rsa',
-
-    # optional attributes:
-    #   :disk_config, :metadata, :personality, :config_drive,
-    #   :boot_volume_id, :boot_image_id
-    #
-    # ** :image_id must be "" if :boot_volume_id or :boot_image_id is provided
-  }
-})
-
-machine 'mario' do
-  tag 'itsa_me'
-  converge true
-end
-```
-
-If you run into SSH key trouble, [see this issue](https://github.com/chef/chef-provisioning-fog/issues/130) for some background of the chef-provisioning-fog driver and the fog library's different ways of bootstraping a server at Rackspace.
+For a full example see [examples/rackspace/simple.rb](examples/rackspace/simple.rb).
 
 ### Cleaning up
 
@@ -203,6 +122,58 @@ The driver API is separated out so that new drivers can be made with minimal eff
 
 Drivers save their data in the Chef node itself, so that they will be accessible to everyone who is using the Chef server to manage the nodes.
 
+### Tuning Timeouts
+
+`chef-provisioning-fog` interacts with your cloud provider's endpoint.  Most of
+the time, default timeouts for the following would be sufficient.
+
+#### Fog `connection_options`
+
+Modify the defaults if your Fog endpoint takes awhile to send/receive API requests.  Normally, if you see `Excon` timeouts you should tune these [parameters](https://github.com/excon/excon/blob/75d85a7e304cbd1c9dc3c7c40c6de5a995f5cd04/lib/excon/constants.rb#L110-L139).
+
+```ruby
+with_driver 'fog:foo',
+  :compute_options => {
+    :connection_options => {
+      # set connection to persist (default is false)
+      :persistent => true,
+      # set longer connect_timeout (default is 60 seconds)
+      :connect_timeout => 360,
+      # set longer read_timeout (default is 60 seconds)
+      :read_timeout => 360,
+      # set longer write_timeout (default is 60 seconds)
+      :write_timeout => 360,
+    }
+  }
+```
+#### `machine_option` timeouts
+
+Modify these timeouts if you need Chef to wait a bit of time to allow for the machine to be ready.
+
+```ruby
+with_machine_options({
+  # set longer to wait for the instance to boot to ssh (defaults to 180)
+  :create_timeout => 360,
+  # set longer to wait for the instance to start (defaults to 180)
+  :start_timeout => 360,
+  # set longer to wait for ssh to be available if the instance is detected up (defaults to 20)
+  :ssh_timeout => 360
+})
+```
+
+#### Chef Client `convergence_options`
+
+Modify this if your chef client convergences take awhile.
+
+```ruby
+with_machine_options({
+  :convergence_options => {
+    # set longer if you need more time to converge (default: 2 hours)
+    :chef_client_timeout => 120*60
+  }
+})
+```
+
 [gem]: https://rubygems.org/gems/chef-provisioning-fog
 [travis]: https://travis-ci.org/chef/chef-provisioning-fog
 [gemnasium]: https://gemnasium.com/chef/chef-provisioning-fog

data/chef-provisioning-fog.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.homepage = 'https://github.com/opscode/chef-provisioning-fog'
 
   s.add_dependency 'chef-provisioning', '~> 1.0'
-  s.add_dependency 'fog'
+  s.add_dependency 'fog', '>= 1.35.0'
   s.add_dependency 'retryable'
 
   s.add_development_dependency 'rspec'

data/lib/chef/provider/fog_key_pair.rb

@@ -216,7 +216,7 @@ class Chef::Provider::FogKeyPair < Chef::Provider::LWRPBase
       current_key_pair = compute.ssh_keys.select { |key| key.name == new_resource.name }.first
       if current_key_pair
         @current_id = current_key_pair.id
-        @current_fingerprint = current_key_pair ? compute.ssh_keys.get(@current_id).ssh_pub_key : nil
+        @current_fingerprint = current_key_pair ? compute.ssh_keys.get(@current_id).public_key : nil
       else
         current_resource.action :delete
       end

data/lib/chef/provisioning/fog_driver/driver.rb

@@ -297,7 +297,7 @@ module FogDriver
       specs_and_options.each do |machine_spec, machine_options|
         server = specs_and_servers[machine_spec]
         if server
-          if %w(terminated archive).include?(server.state) # Can't come back from that
+          if %w(terminated archive).include?(server.status) # Can't come back from that
             Chef::Log.warn "Machine #{machine_spec.name} (#{server.id} on #{driver_url}) is terminated.  Recreating ..."
           else
             yield machine_spec, server if block_given?
@@ -370,14 +370,14 @@ module FogDriver
     end
 
     def start_server(action_handler, machine_spec, server)
-      # If it is stopping, wait for it to get out of "stopping" transition state before starting
-      if server.state == 'stopping'
+      # If it is stopping, wait for it to get out of "stopping" transition status before starting
+      if server.status == 'stopping'
         action_handler.report_progress "wait for #{machine_spec.name} (#{server.id} on #{driver_url}) to finish stopping ..."
-        server.wait_for { server.state != 'stopping' }
+        server.wait_for { server.status != 'stopping' }
         action_handler.report_progress "#{machine_spec.name} is now stopped"
       end
 
-      if server.state == 'stopped'
+      if server.status == 'stopped'
         action_handler.perform_action "start machine #{machine_spec.name} (#{server.id} on #{driver_url})" do
           server.start
           machine_spec.reference['started_at'] = Time.now.to_i
@@ -633,6 +633,7 @@ module FogDriver
     # @param [Chef::Provisioning::Machine] server a Machine representing the server
     # @return [String] PEM-encoded private key
     def private_key_for(machine_spec, machine_options, server)
+      bootstrap_options = machine_options[:bootstrap_options] || {}
       if server.respond_to?(:private_key) && server.private_key
          server.private_key
       elsif server.respond_to?(:key_name) && server.key_name
@@ -647,13 +648,14 @@ module FogDriver
           raise "Server was created with key name '#{machine_spec.reference['key_name']}', but the corresponding private key was not found locally.  Check if the key is in Chef::Config.private_key_paths: #{Chef::Config.private_key_paths.join(', ')}"
         end
         key
-      elsif machine_options[:bootstrap_options][:key_path]
-        IO.read(machine_options[:bootstrap_options][:key_path])
-      elsif machine_options[:bootstrap_options][:key_name]
-        get_private_key(machine_options[:bootstrap_options][:key_name])
+      elsif bootstrap_options[:key_path]
+        IO.read(bootstrap_options[:key_path])
+      elsif bootstrap_options[:key_name]
+        get_private_key(bootstrap_options[:key_name])
       else
         # TODO make a way to suggest other keys to try ...
-        raise "No key found to connect to #{machine_spec.name} (#{machine_spec.reference.inspect})!"
+        raise "No key found to connect to #{machine_spec.name} (#{machine_spec.reference.inspect})" \
+          " : machine_options -> (#{machine_options.inspect})!"
       end
     end
 

data/lib/chef/provisioning/fog_driver/providers/digitalocean.rb

@@ -16,7 +16,7 @@ module FogDriver
 
       def bootstrap_options_for(action_handler, machine_spec, machine_options)
         bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
-        if bootstrap_options[:key_path]
+        if bootstrap_options[:key_path] || bootstrap_options[:key_name]
           bootstrap_options[:key_name] ||= File.basename(bootstrap_options[:key_path])
           # Verify that the provided key name and path are in line (or create the key pair if not!)
           driver = self
@@ -27,12 +27,12 @@ module FogDriver
             end
           end
         else
-          bootstrap_options[:key_name] = overwrite_default_key_willy_nilly(action_handler, machine_spec)
+          bootstrap_options[:key_name] ||= overwrite_default_key_willy_nilly(action_handler, machine_spec)
         end
 
         bootstrap_options[:tags]  = default_tags(machine_spec, bootstrap_options[:tags] || {})
 
-        if !bootstrap_options[:image_id]
+        if !bootstrap_options[:image_id] && !bootstrap_options[:image]
           if !bootstrap_options[:image_distribution] && !bootstrap_options[:image_name]
             bootstrap_options[:image_distribution] = 'CentOS'
             bootstrap_options[:image_name] = '6.5 x64'
@@ -45,44 +45,44 @@ module FogDriver
           if images.empty?
             raise "No images on DigitalOcean with distribution #{bootstrap_options[:image_distribution].inspect} and name #{bootstrap_options[:image_name].inspect}"
           end
-          bootstrap_options[:image_id] = images.first.id
+          bootstrap_options[:image] = images.first.id
         end
-        if !bootstrap_options[:flavor_id]
+        if !bootstrap_options[:flavor_id] && !bootstrap_options[:size]
           bootstrap_options[:flavor_name] ||= '512MB'
           flavors = compute.flavors.select do |f|
-            f.name == bootstrap_options[:flavor_name]
+            f.slug.downcase == bootstrap_options[:flavor_name].downcase
           end
           if flavors.empty?
             raise "Could not find flavor named '#{bootstrap_options[:flavor_name]}' on #{driver_url}"
           end
-          bootstrap_options[:flavor_id] = flavors.first.id
+          bootstrap_options[:size] = flavors.first.slug
         end
-        if !bootstrap_options[:region_id]
+        if !bootstrap_options[:region]
           bootstrap_options[:region_name] ||= 'San Francisco 1'
           regions = compute.regions.select { |region| region.name == bootstrap_options[:region_name] }
           if regions.empty?
             raise "Could not find region named '#{bootstrap_options[:region_name]}' on #{driver_url}"
           end
-          bootstrap_options[:region_id] = regions.first.id
+          bootstrap_options[:region] = regions.first.slug
         end
         keys = compute.ssh_keys.select { |k| k.name == bootstrap_options[:key_name] }
         if keys.empty?
           raise "Could not find key named '#{bootstrap_options[:key_name]}' on #{driver_url}"
         end
         found_key = keys.first
-        bootstrap_options[:ssh_key_ids] ||= [ found_key.id ]
+        bootstrap_options[:ssh_keys] ||= [ found_key.id ]
 
         # You don't get to specify name yourself
         bootstrap_options[:name] = machine_spec.name
-
+        bootstrap_options[:version] ||= :v2
         bootstrap_options
       end
 
       def destroy_machine(action_handler, machine_spec, machine_options)
         server = server_for(machine_spec)
-        if server && server.state != 'archive'
+        if server && server.status != 'archive'
           action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.location['server_id']} at #{driver_url})" do
-            server.destroy
+            server.delete
           end
         end
         machine_spec.location = nil
@@ -95,38 +95,14 @@ module FogDriver
         new_compute_options[:provider] = provider
         new_config = { :driver_options => { :compute_options => new_compute_options }}
         new_defaults = {
-          :driver_options  => { :compute_options => {} },
+          :driver_options  => { :compute_options => { version: :v2 } },
           :machine_options => { :bootstrap_options => {}, :ssh_options => {} }
         }
         result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
 
-        new_compute_options[:digitalocean_client_id] = id if (id && id != '')
-
-        # This uses ~/.tugboat, generated by "tugboat authorize" - see https://github.com/pearkes/tugboat
-        tugboat_file = File.expand_path('~/.tugboat')
-        if File.exist?(tugboat_file)
-          tugboat_data = YAML.load(IO.read(tugboat_file))
-
-          new_bootstrap_options = new_defaults[:machine_options][:bootstrap_options]
-          if tugboat_data['authentication']
-            new_compute_options[:digitalocean_client_id] = tugboat_data['authentication']['client_key'] if tugboat_data['authentication']['client_key'] && tugboat_data['authentication']['client_key'].size > 0
-            new_compute_options[:digitalocean_api_key]   = tugboat_data['authentication']['api_key']    if tugboat_data['authentication']['api_key']    && tugboat_data['authentication']['api_key'].size > 0
-          end
-          if tugboat_data['defaults']
-            new_bootstrap_options[:region_id] = tugboat_data['defaults']['region'].to_i if tugboat_data['defaults']['region'] && tugboat_data['defaults']['region'].size > 0
-            new_bootstrap_options[:image_id]  = tugboat_data['defaults']['image'].to_i  if tugboat_data['defaults']['image']  && tugboat_data['defaults']['image'].size > 0
-            new_bootstrap_options[:size_id]   = tugboat_data['defaults']['size'].to_i   if tugboat_data['defaults']['size']   && tugboat_data['defaults']['size'].size > 0
-            new_bootstrap_options[:private_networking] = (tugboat_data['defaults']['private_networking'] == 'true') if tugboat_data['defaults']['private_networking'] && tugboat_data['defaults']['private_networking'].size > 0
-            new_bootstrap_options[:backups_enabled]    = (tugboat_data['defaults']['backups_enabled']    == 'true') if tugboat_data['defaults']['backups_enabled'] && tugboat_data['defaults']['backups_enabled'].size > 0
-            new_bootstrap_options[:key_name] = tugboat_data['defaults']['ssh_key'] if tugboat_data['defaults']['ssh_key'] && tugboat_data['defaults']['ssh_key'].size > 0
-          end
-          if tugboat_data['ssh']
-            new_bootstrap_options[:key_path] = tugboat_data['ssh']['ssh_key_path'] if tugboat_data['ssh']['ssh_key_path'] && tugboat_data['ssh']['ssh_key_path'].size > 0
-            new_defaults[:machine_options][:ssh_options][:port] = tugboat_data['ssh']['ssh_port'] if tugboat_data['ssh']['ssh_port'] if tugboat_data['ssh']['ssh_port'].size > 0
-          end
-        end
+        new_compute_options[:digitalocean_token] = id if (id && id != '')
 
-        [result, new_compute_options[:digitalocean_client_id]]
+        [result, new_compute_options[:digitalocean_token]]
       end
 
     end

data/lib/chef/provisioning/fog_driver/version.rb

@@ -1,7 +1,7 @@
 class Chef
   module Provisioning
     module FogDriver
-      VERSION = '0.15.3'
+      VERSION = '0.16.0'
     end
   end
 end

data/spec/spec_helper.rb

@@ -2,7 +2,7 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 $:.unshift File.expand_path('../support', __FILE__)
 require 'fog'
 require 'chef/provisioning'
-require 'chef/provisioning/fog_driver'
+require 'chef/provisioning/fog_driver/driver'
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true

data/spec/support/aws/config-file.csv

@@ -1,2 +1,2 @@
 User Name,Access Key Id,Secret Access Key
-test,12345,abcde
+test,67890,fghij

data/spec/support/chef/provisioning/fog_driver/providers/testdriver.rb

@@ -0,0 +1,20 @@
+class Chef
+  module Provisioning
+    module FogDriver
+      module Providers
+        class TestDriver < FogDriver::Driver
+          Driver.register_provider_class('TestDriver', Chef::Provisioning::FogDriver::Providers::TestDriver)
+
+          attr_reader :config
+          def initialize(driver_url, config)
+            super
+          end
+
+          def self.compute_options_for(provider, id, config)
+            [config, 'test']
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/chef/provisioning/fog_driver/driver_spec.rb

@@ -68,4 +68,43 @@ describe Chef::Provisioning::FogDriver::Driver do
       end
     end
   end
+
+  describe '#private_key_for' do
+    let(:machine_spec) { double('machine_spec', reference: {}, name: 'my_machine') }
+    let(:machine_options) { { bootstrap_options:  bootstrap_options } }
+
+    context 'when the machine has a key path in bootstrap options' do
+      let(:bootstrap_options) { { key_path: '/tmp/test_private_key_file' } }
+
+      it 'reads the key file' do
+        allow(IO).to receive(:read).and_return 'test_private_key'
+        expect(driver.private_key_for(machine_spec, machine_options, nil)).to eq 'test_private_key'
+      end
+    end
+
+    context 'when the machine has a key name in bootstrap options' do
+      let(:bootstrap_options) { { key_name: 'test_private_key_name' } }
+
+      it 'calls get_private_key' do
+        expect(driver).to receive(:get_private_key).with('test_private_key_name').and_return 'test_private_key'
+        expect(driver.private_key_for(machine_spec, machine_options, nil)).to eq 'test_private_key'
+      end
+    end
+
+    context 'when the machine has no bootstrap options' do
+      it 'raises an error' do
+        expect { driver.private_key_for(machine_spec, {}, nil) }
+          .to raise_error(RuntimeError, 'No key found to connect to my_machine ({}) : machine_options -> ({})!')
+      end
+    end
+
+    context 'when the machine has no key path or key name bootstrap options' do
+      let(:bootstrap_options) { {} }
+
+      it 'raises an error' do
+        expect { driver.private_key_for(machine_spec, machine_options, nil) }.to raise_error(
+          RuntimeError, 'No key found to connect to my_machine ({}) : machine_options -> ({:bootstrap_options=>{}})!')
+      end
+    end
+  end
 end

data/spec/unit/fog_driver_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
-require 'chef/provisioning/fog_driver'
+require 'chef/provisioning/fog_driver/providers/testdriver'
 
 describe Chef::Provisioning::FogDriver do
 
   describe ".from_url" do
-    subject { Chef::Provisioning::FogDriver.from_provider('TestDriver', {}) }
+    subject { Chef::Provisioning::FogDriver::Driver.from_provider('TestDriver', {}) }
 
     it "should return the correct class" do
       expect(subject).to be_an_instance_of Chef::Provisioning::FogDriver::Providers::TestDriver
@@ -20,12 +20,12 @@ describe Chef::Provisioning::FogDriver do
 
   describe "when creating a new class" do
     it "should return the correct class" do
-      test = Chef::Provisioning::FogDriver.new('fog:TestDriver:foo', {})
+      test = Chef::Provisioning::FogDriver::Driver.new('fog:TestDriver:foo', {})
       expect(test).to be_an_instance_of Chef::Provisioning::FogDriver::Providers::TestDriver
     end
 
     it "should populate config" do
-      test = Chef::Provisioning::FogDriver.new('fog:TestDriver:foo', {test: "chef_provisioning"})
+      test = Chef::Provisioning::FogDriver::Driver.new('fog:TestDriver:foo', {test: "chef_provisioning"})
       expect(test.config[:test]).to eq "chef_provisioning"
     end
   end

data/spec/unit/providers/aws/credentials_spec.rb

@@ -1,45 +1,47 @@
 require 'chef/provisioning/fog_driver/providers/aws/credentials'
 
 describe Chef::Provisioning::FogDriver::Providers::AWS::Credentials do
-  describe "#load_ini" do
+  let(:credentials) { Chef::Provisioning::FogDriver::Providers::AWS::Credentials.new }
+  
+  describe "#load_inis" do
     let(:aws_credentials_ini_file) { File.join(File.expand_path('../../../../support', __FILE__), 'aws/ini-file.ini') }
 
     before do
-      described_class.load_ini(aws_credentials_ini_file)
+      credentials.load_inis(aws_credentials_ini_file)
     end
 
     it "should load a default profile" do
-      expect(described_class['default']).to include(:aws_access_key_id)
+      expect(credentials['default']).to include(:aws_access_key_id)
     end
 
     it "should load the correct values" do
-      expect(described_class['default'][:aws_access_key_id]).to eq "12345"
-      expect(described_class['default'][:aws_secret_access_key]).to eq "abcde"
-      expect(described_class['default'][:region]).to eq "us-east-1"
-      expect(described_class['default'][:aws_session_token]).to eq "mysecret"
+      expect(credentials['default'][:aws_access_key_id]).to eq "12345"
+      expect(credentials['default'][:aws_secret_access_key]).to eq "abcde"
+      expect(credentials['default'][:region]).to eq "us-east-1"
+      expect(credentials['default'][:aws_session_token]).to eq "mysecret"
     end
 
     it "should load several profiles" do
-      expect(described_class.keys.length).to eq 2
+      expect(credentials.keys.length).to eq 2
     end
   end
 
   describe "#load_csv" do
     let(:aws_credentials_csv_file) { File.join(File.expand_path('../../../../support', __FILE__), 'aws/config-file.csv') }
     before do
-      described_class.load_csv(aws_credentials_csv_file)
+      credentials.load_csv(aws_credentials_csv_file)
     end
 
     it "should load a single profile" do
-      expect(described_class['default']).to include(:aws_access_key_id)
+      expect(credentials['test']).to include(:aws_access_key_id)
     end
 
     it "should load the correct values" do
-      expect(described_class['default'][:aws_access_key_id]).to eq "12345"
+      expect(credentials['test'][:aws_access_key_id]).to eq "67890"
     end
 
     it "should load several profiles" do
-      expect(described_class.keys.length).to eq 2
+      expect(credentials.keys.length).to eq 1
     end
   end
 end

data/spec/unit/providers/rackspace_spec.rb

@@ -1,8 +1,14 @@
-require 'chef/provisioning/fog_driver'
+require 'spec_helper'
 require 'chef/provisioning/fog_driver/providers/rackspace'
 
 describe Chef::Provisioning::FogDriver::Providers::Rackspace do
-  subject { Chef::Provisioning::FogDriver.from_provider('Rackspace',{}) }
+  subject do
+    Chef::Provisioning::FogDriver::Driver.from_provider(
+      'Rackspace', driver_options: { compute_options: { 
+                   rackspace_username: 'test_username', rackspace_api_key: 'test_api_key'} 
+                 }
+    )
+  end
 
   it "returns the correct driver" do
     expect(subject).to be_an_instance_of Chef::Provisioning::FogDriver::Providers::Rackspace

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-fog
 version: !ruby/object:Gem::Version
-  version: 0.15.3
+  version: 0.16.0
 platform: ruby
 authors:
 - John Keiser
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-09 00:00:00.000000000 Z
+date: 2016-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-provisioning
@@ -33,14 +33,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.35.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.35.0
 - !ruby/object:Gem::Dependency
   name: retryable
   requirement: !ruby/object:Gem::Requirement
@@ -120,7 +120,7 @@ files:
 - spec/spec_helper.rb
 - spec/support/aws/config-file.csv
 - spec/support/aws/ini-file.ini
-- spec/support/chef_metal_fog/providers/testdriver.rb
+- spec/support/chef/provisioning/fog_driver/providers/testdriver.rb
 - spec/unit/chef/provisioning/fog_driver/driver_spec.rb
 - spec/unit/fog_driver_spec.rb
 - spec/unit/providers/aws/credentials_spec.rb
@@ -144,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Driver for creating Fog instances in Chef Provisioning.

data/spec/support/chef_metal_fog/providers/testdriver.rb

@@ -1,16 +0,0 @@
-class Chef
-module Provisioning
-class FogDriver::Providers
-  class TestDriver < Chef::Provisioning::FogDriver
-    Chef::Provisioning::FogDriver.register_provider_class('TestDriver', Chef::Provisioning::FogDriver::Providers::TestDriver)
-
-    attr_reader :config
-    def initialize(driver_url, config)
-      super
-    end
-
-    def self.compute_options_for(provider, id, config)
-      [config, 'test']
-    end
-  end
-end