vagrant-openstack-cloud-provider 1.1.8 → 1.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b182a701fd3c8e02f164f19c6726ac2b541b4ca
-  data.tar.gz: bb49494f4566256877a45da8ee63a86c9cfc9608
+  metadata.gz: 757087dec480ba560e7fcd2d238842934b5c5084
+  data.tar.gz: 5a2516fb166f82f322f54f5abbefc8b38adc39c5
 SHA512:
-  metadata.gz: 6df57c41d76339adbbfbaca7e803005fe5b59b3ffaf9eb761cfa33b75d7f9990f4fd8d4938a8f6dafe3cc177577a3de29af3d23416cd22ad78590657b95888e5
-  data.tar.gz: 5b88e61657a1134664e58359d24739b1305323f51824a2c2107fc78c1cae6641a62923db85e60e39859bb776a81067e309bf4ee10e0650dab56b9561049ae21f
+  metadata.gz: 65b8aa57e0fb0df88abef0b65f9949b0a9e4e8cf8de267946a3205e250d36b9841ce025e6ed56b292467aa2c35ac168eb67a4ce4a13fcec24e4345e13cfb9517
+  data.tar.gz: c3f159790ba459a74093074590bd7a31ae22c244f2dfc388aeba6d8f905fb8c4601926c17b4596882f597d8d488bd4cabcfe899ac05232d89897fe64930012d2

data/lib/vagrant-openstack-cloud-provider/action/connect_openstack.rb

@@ -1,5 +1,6 @@
 require "fog"
 require "log4r"
+require 'promise'
 
 module VagrantPlugins
   module OpenStack
@@ -14,20 +15,31 @@ module VagrantPlugins
         end
 
         def call(env)
-          # Get the configs
-          config   = env[:machine].provider_config
-          @logger.info("Connecting to OpenStack Compute...")
-          env[:openstack_compute] = Fog::Compute.new({
-                        :provider => :openstack,
-                        :openstack_region => config.region,
-                        :openstack_username => config.username,
-                        :openstack_api_key => config.api_key,
-                        :openstack_auth_url => config.endpoint,
-                        :openstack_tenant => config.tenant
-                    })
+          config = env[:machine].provider_config
+
+          openstack_options = {
+              :provider => :openstack,
+              :openstack_region => config.region,
+              :openstack_username => config.username,
+              :openstack_api_key => config.api_key,
+              :openstack_auth_url => config.endpoint,
+              :openstack_tenant => config.tenant
+          }
+
+          env[:openstack_compute] = get_fog_promise('Compute', openstack_options)
+          env[:openstack_network] = get_fog_promise('Network', openstack_options)
 
           @app.call(env)
         end
+
+        private
+
+        def get_fog_promise(service_name, openstack_options)
+          promise {
+            @logger.info("Initializing OpenStack #{service_name}...")
+            Fog.const_get(service_name).new(openstack_options)
+          }
+        end
       end
     end
   end

data/lib/vagrant-openstack-cloud-provider/action/create_server.rb

@@ -23,19 +23,7 @@ module VagrantPlugins
 
         def call(env)
           # Get the configs
-          config   = env[:machine].provider_config
-
-          if !config.networks.nil? and config.networks.any?
-            @logger.info("Connecting to OpenStack Network...")
-            env[:openstack_network] = Fog::Network.new({
-                          :provider => :openstack,
-                          :openstack_region => config.region,
-                          :openstack_username => config.username,
-                          :openstack_api_key => config.api_key,
-                          :openstack_auth_url => config.endpoint,
-                          :openstack_tenant => config.tenant
-                      })
-          end
+          config = env[:machine].provider_config
 
           # Find the flavor
           env[:ui].info(I18n.t("vagrant_openstack.finding_flavor"))
@@ -115,15 +103,15 @@ module VagrantPlugins
 
             # Wait for the server to be ready
             begin
-              (1..config.instance_build_timeout).each do |n|
+              (1..config.instance_build_timeout / config.instance_build_status_check_interval).each do |n|
                 if config.report_progress
                   env[:ui].clear_line
-                  env[:ui].report_progress(n, false)
+                  env[:ui].report_progress(n * config.instance_build_status_check_interval, false)
                 end
 
                 server = env[:openstack_compute].servers.get(env[:machine].id)
                 break if self.server_to_be_available?(server)
-                sleep 1
+                sleep config.instance_build_status_check_interval
               end
               server = env[:openstack_compute].servers.get(env[:machine].id)
               raise unless self.server_to_be_available?(server)
@@ -142,27 +130,30 @@ module VagrantPlugins
           unless env[:interrupted]
             # Clear the line one more time so the progress is removed
             env[:ui].clear_line
-            ssh_is_responding?(env)
+            ssh_is_responding?(env,
+                               timeout=config.instance_ssh_timeout,
+                               sleep_interval=config.instance_ssh_check_interval)
             env[:ui].info(I18n.t("vagrant_openstack.ready",
                           :elapsed => (Time.now - launch_start_time).floor))
           end
 
           @app.call(env)
         end
+
         protected
 
-        def ssh_is_responding?(env)
+        def ssh_is_responding?(env, timeout, sleep_interval)
            begin
              # Wait for SSH to become available
              env[:ui].info(I18n.t("vagrant_openstack.waiting_for_ssh"))
-             (1..60).each do |n|
+             (1..timeout / sleep_interval).each do |n|
                begin
                  # If we're interrupted then just back out
                  break if env[:interrupted]
                  break if env[:machine].communicate.ready?
                rescue Errno::ENETUNREACH
                end
-               sleep 2
+               sleep sleep_interval
              end
              raise unless env[:machine].communicate.ready?
            rescue

data/lib/vagrant-openstack-cloud-provider/config.rb

@@ -1,4 +1,5 @@
 require "vagrant"
+require "vagrant-openstack-cloud-provider/utils"
 
 module VagrantPlugins
   module OpenStack
@@ -70,14 +71,22 @@ module VagrantPlugins
       # @return [Hash]
       attr_accessor :scheduler_hints
 
-      # @return [String]
-      attr_accessor :instance_build_timeout
+      # @return [Integer]
+      casting_attr_accessor :instance_build_timeout, Integer, greater_than(0)
+
+      # @return [Integer]
+      casting_attr_accessor :instance_build_status_check_interval, Integer, greater_than(0)
+
+      # @return [Integer]
+      casting_attr_accessor :instance_ssh_timeout, Integer, greater_than(0)
+
+      # @return [Integer]
+      casting_attr_accessor :instance_ssh_check_interval, Integer, greater_than(0)
 
       # @return [Bool]
       attr_accessor :report_progress
       # alias_method :report_progress?, :report_progress
 
-
       def initialize
         @api_key  = UNSET_VALUE
         @endpoint = UNSET_VALUE
@@ -95,6 +104,9 @@ module VagrantPlugins
         @tenant = UNSET_VALUE
         @scheduler_hints = UNSET_VALUE
         @instance_build_timeout = UNSET_VALUE
+        @instance_build_status_check_interval = UNSET_VALUE
+        @instance_ssh_timeout = UNSET_VALUE
+        @instance_ssh_check_interval = UNSET_VALUE
         @report_progress = UNSET_VALUE
       end
 
@@ -122,6 +134,10 @@ module VagrantPlugins
         @tenant = nil if @tenant == UNSET_VALUE
         @scheduler_hints = {} if @scheduler_hints == UNSET_VALUE
         @instance_build_timeout = 120 if @instance_build_timeout == UNSET_VALUE
+        @instance_build_status_check_interval = 1 if @instance_build_status_check_interval == UNSET_VALUE
+        @instance_ssh_timeout = 60 if @instance_ssh_timeout == UNSET_VALUE
+        @instance_ssh_check_interval = 2 if @instance_ssh_check_interval == UNSET_VALUE
+
         @report_progress = true if @report_progress == UNSET_VALUE
       end
 

data/lib/vagrant-openstack-cloud-provider/utils.rb

@@ -0,0 +1,24 @@
+class InvalidValue < StandardError
+end
+
+def greater_than(base_value)
+  lambda { |val| val > base_value }
+end
+
+
+def casting_attr_accessor(accessor, type, *validators)
+
+  define_method(accessor) do
+    instance_variable_get("@#{accessor}")
+  end
+
+  define_method("#{accessor}=") do |val|
+    new_val = Kernel.send(type.to_s, val)
+    if validators and ! validators.all? {|v| v.call(new_val) }
+      raise InvalidValue, val
+    end
+
+    instance_variable_set("@#{accessor}", new_val)
+  end
+end
+

data/lib/vagrant-openstack-cloud-provider/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module OpenStack
-    VERSION = "1.1.8"
+    VERSION = "1.1.9"
   end
 end

data/spec/spec_helper.rb

@@ -9,7 +9,6 @@ SimpleCov.start
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 

data/spec/vagrant-openstack-cloud-provider/action/connect_openstack_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'vagrant-openstack-cloud-provider/errors'
+require 'vagrant-openstack-cloud-provider/action/connect_openstack'
+require "fog"
+
+RSpec.describe VagrantPlugins::OpenStack::Action::ConnectOpenStack do
+  describe '#call?' do
+    let (:app) { double }
+    let (:machine) { double }
+    let (:config) { double(
+        :config,
+        :region    => nil,
+        :username  => 'username',
+        :api_key   => 'password',
+        :endpoint  => 'http://openstack.invalid/',
+        :tenant    => nil,
+      )
+    }
+
+    subject {
+      described_class.new(app, nil)
+    }
+
+    it "should new members in env" do
+      expect(app).to receive(:call)
+      expect(machine).to receive(:provider_config).and_return(config)
+      env = { :machine => machine }
+
+      subject.call(env)
+
+      expect(env).to have_key(:openstack_compute)
+      expect(env).to have_key(:openstack_network)
+    end
+
+    {Fog::Compute => :openstack_compute,
+     Fog::Network => :openstack_network}.each do |klass, attribute|
+      it "should late-evaluate #{klass}" do
+        expect(app).to receive(:call)
+        expect(machine).to receive(:provider_config).and_return(config)
+        env = { :machine => machine }
+
+        expect(klass).to receive(:new).and_raise(MyError)
+
+        subject.call(env)
+
+        expect { env[attribute].any_call }.to raise_error(MyError)
+      end
+    end
+
+  end
+end
+
+class MyError < StandardError
+
+end

data/spec/vagrant-openstack-cloud-provider/action/create_server_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'vagrant-openstack-cloud-provider/errors'
 require 'vagrant-openstack-cloud-provider/action/create_server'
 
-describe VagrantPlugins::OpenStack::Action::CreateServer do
+RSpec.describe VagrantPlugins::OpenStack::Action::CreateServer do
   describe '#server_to_be_available?' do
     subject {
       described_class.new(nil, nil)
@@ -11,12 +11,12 @@ describe VagrantPlugins::OpenStack::Action::CreateServer do
     let(:server) { double }
 
     it "returns true when server is active" do
-      server.stub(:state).and_return('ACTIVE')
-      subject.server_to_be_available?(server).should == true
+      expect(server).to receive(:state).at_least(:once).and_return('ACTIVE')
+      expect(subject.server_to_be_available?(server)).to eq(true)
     end
 
     it "should raise when the server state is ERROR" do
-      server.stub(:state).and_return('ERROR')
+      expect(server).to receive(:state).at_least(:once).and_return('ERROR')
       expect { subject.server_to_be_available?(server) }.to raise_error(RuntimeError)
     end
   end
@@ -31,19 +31,21 @@ describe VagrantPlugins::OpenStack::Action::CreateServer do
     let(:communicate) { double }
 
     it "should continue if ssh is available" do
-      ui.stub(:info)
-      communicate.stub(:ready?).and_return(true)
-      machine.stub(:communicate).and_return(communicate)
+      expect(ui).to receive(:info).at_least(:once)
+      expect(communicate).to receive(:ready?).twice.and_return(true)
+      expect(machine).to receive(:communicate).at_least(:once).and_return(communicate)
+
       env = { :ui => ui, :interrupted => false, :machine => machine }
-      subject.send('ssh_is_responding?', env)
+      subject.send('ssh_is_responding?', env, timeout=1, sleep_interval=0.001)
     end
 
     it "should raise if ssh isn't available" do
-      ui.stub(:info)
-      communicate.stub(:ready?).and_return(false)
-      machine.stub(:communicate).and_return(communicate)
+      expect(ui).to receive(:info).at_least(:once)
+      expect(communicate).to receive(:ready?).exactly(6).times.and_return(false)
+      expect(machine).to receive(:communicate).at_least(:once).and_return(communicate)
+
       env = { :ui => ui, :interrupted => false, :machine => machine }
-      expect { subject.send('ssh_is_responding?', env) }.to raise_error(VagrantPlugins::OpenStack::Errors::SshUnavailable)
+      expect { subject.send('ssh_is_responding?', env, timeout=0.005, sleep_interval=0.001) }.to raise_error(VagrantPlugins::OpenStack::Errors::SshUnavailable)
     end
   end
 
@@ -56,34 +58,34 @@ describe VagrantPlugins::OpenStack::Action::CreateServer do
       haystack = [{"status"=>"ACTIVE", "subnets"=>["d8908f8c-07f4-405b-bbab-e19c768f293f"], "name"=>"solidfire", "provider:physical_network"=>"physnet1", "admin_state_up"=>true, "tenant_id"=>"2c9fba23721f4126ab244020e641f5f5", "provider:network_type"=>"vlan", "router:external"=>false, "shared"=>true, "id"=>"192702e6-3444-4162-b244-3af8b50fbb45", "provider:segmentation_id"=>3999}, {"status"=>"ACTIVE", "subnets"=>["d4318e28-5acd-415f-b300-0502f33b0dea"], "name"=>"public", "provider:physical_network"=>"physnet0", "admin_state_up"=>true, "tenant_id"=>"2c9fba23721f4126ab244020e641f5f5", "provider:network_type"=>"vlan", "router:external"=>false, "shared"=>true, "id"=>"e44bf8cb-7326-4abc-b96d-5404d5ed7767", "provider:segmentation_id"=>2753}]
       needle = {"status"=>"ACTIVE", "subnets"=>["d4318e28-5acd-415f-b300-0502f33b0dea"], "name"=>"public", "provider:physical_network"=>"physnet0", "admin_state_up"=>true, "tenant_id"=>"2c9fba23721f4126ab244020e641f5f5", "provider:network_type"=>"vlan", "router:external"=>false, "shared"=>true, "id"=>"e44bf8cb-7326-4abc-b96d-5404d5ed7767", "provider:segmentation_id"=>2753}
 
-      subject.send('find_matching', haystack, needle['name']).should == needle
+      expect(subject.send('find_matching', haystack, needle['name'])).to eq(needle)
     end
 
     it "returns a match for a list of objects with matching id" do
-      object1 = double()
-      object1.stub('id' => 'matching_value')
-      object1.stub('name' => 'not_this')
+      object1 = double(:object1,
+                       :id => 'matching_value',
+                       :name => 'not_this')
 
       haystack = [object1]
-      subject.send('find_matching', haystack, 'matching_value').should == object1
+      expect(subject.send('find_matching', haystack, 'matching_value')).to equal(object1)
     end
 
     it "returns a match for a list of objects with matching name" do
-      object1 = double()
-      object1.stub('id' => 'not_this')
-      object1.stub('name' => 'matching_value')
+      object1 = double(:object1,
+                       :id => 'not_this',
+                       :name => 'matching_value')
 
       haystack = [object1]
-      subject.send('find_matching', haystack, 'matching_value').should == object1
+      expect(subject.send('find_matching', haystack, 'matching_value')).to equal(object1)
     end
 
     it "returns a match for a list of objects with a matching regexp" do
-      object1 = double()
-      object1.stub('id' => 'not_this')
-      object1.stub('name' => '2020 des fin fin')
+      object1 = double(:object1,
+                       :id => 'not_this',
+                       :name => '2020 des fin fin')
 
       haystack = [object1]
-      subject.send('find_matching', haystack, /des fin/).should == object1
+      expect(subject.send('find_matching', haystack, /des fin/)).to equal(object1)
     end
   end
 end

data/spec/vagrant-openstack-cloud-provider/action/read_ssh_info_spec.rb

@@ -1,26 +1,26 @@
 require 'spec_helper'
 require 'vagrant-openstack-cloud-provider/action/read_ssh_info_from_api'
 
-describe VagrantPlugins::OpenStack::Action::ReadSSHInfoFromAPI do
+RSpec.describe VagrantPlugins::OpenStack::Action::ReadSSHInfoFromAPI do
   describe '#call' do
     it "passes proper parameters to read_ssh_info and puts them in machine_ssh_info" do
       app = lambda { |only_one_parameter| }
       env = {:openstack_compute => :my_compute, :machine => :my_machine}
 
       subject = described_class.new(app, nil)
-      subject.should_receive(:read_ssh_info).with(:my_compute, :my_machine).and_return(:my_ssh_info)
+      expect(subject).to receive(:read_ssh_info).with(:my_compute, :my_machine).and_return(:my_ssh_info)
 
       subject.call(env)
-      env[:machine_ssh_info].should == :my_ssh_info
+      expect(env[:machine_ssh_info]).to eq(:my_ssh_info)
     end
 
     it "calls app.call with the right env" do
       app = double()
       env = {:openstack_compute => nil, :machine => nil}
-      app.should_receive(:call).with(env)
+      expect(app).to receive(:call).with(env)
 
       subject = described_class.new(app, nil)
-      subject.stub(:read_ssh_info)
+      expect(subject).to receive(:read_ssh_info)
       subject.call(env)
     end
   end
@@ -33,48 +33,45 @@ describe VagrantPlugins::OpenStack::Action::ReadSSHInfoFromAPI do
     let(:machine) { double }
     let(:openstack) { double }
     let(:servers) { double }
-    let(:provider_config) do
-      mock = double
-      mock.stub(:public_network_name => "public")
-      mock.stub(:ssh_username => "username")
-      mock
-    end
+    let(:invalid_openstack_server_instance) { double }
+    let(:openstack_server_instance) { double }
+    let(:provider_config) { double(:config,
+                                   :public_network_name => "public",
+                                   :ssh_username => "username")
+    }
 
     it "should return nil if machine is nil" do
-      machine.stub(:id).and_return(nil)
-      subject.read_ssh_info(nil, machine).should == nil
+      expect(machine).to receive(:id).and_return(nil)
+      expect(subject.read_ssh_info(nil, machine)).to eq(nil)
     end
 
     it "assigns machine_id to nil and returns nil if openstack returns nil" do
-      machine.stub(:id => "anything")
-      machine.stub(:id=)
+      expect(machine).to receive(:id).at_least(:once).and_return("anything")
+      expect(machine).to receive(:id=).at_least(:once)
 
-      servers.should_receive(:get).and_return(nil)
-      openstack.should_receive(:servers).and_return(servers)
+      expect(servers).to receive(:get).and_return(nil)
+      expect(openstack).to receive(:servers).and_return(servers)
 
-      subject.read_ssh_info(openstack, machine).should == nil
+      expect(subject.read_ssh_info(openstack, machine)).to eq(nil)
     end
 
     it "returns nil when something bad happens while fetching address" do
-      provider_config.stub(:ssh_username)
-      machine.stub(:id => "anything")
-      machine.stub(:provider_config => provider_config)
+      expect(machine).to receive(:id).at_least(:once).and_return("anything")
+      expect(machine).to receive(:provider_config).and_return(provider_config)
 
-      invalid_openstack_server_instance = double()
-      invalid_openstack_server_instance.should_receive(:addresses).and_raise(StandardError)
-      servers.should_receive(:get).and_return(invalid_openstack_server_instance)
-      openstack.should_receive(:servers).and_return(servers)
+      expect(invalid_openstack_server_instance).to receive(:addresses).and_raise(StandardError)
+      expect(servers).to receive(:get).and_return(invalid_openstack_server_instance)
+      expect(openstack).to receive(:servers).and_return(servers)
 
       result = subject.read_ssh_info(openstack, machine)
 
-      result[:port].should == 22
-      result[:host].should == nil
+      expect(result).to eq({:port => 22, :username => 'username', :host => nil})
     end
 
     it "returns a proper ssh_info hash" do
-      provider_config.stub(:ssh_username => "root")
-      machine.stub(:id => "anything")
-      machine.stub(:provider_config => provider_config)
+      expect(provider_config).to receive(:ssh_username).and_return("root")
+      expect(machine).to receive(:id).at_least(:once).and_return("anything")
+      expect(machine).to receive(:provider_config).and_return(provider_config)
 
       valid_server_addresses = {
         "public" => [
@@ -83,23 +80,21 @@ describe VagrantPlugins::OpenStack::Action::ReadSSHInfoFromAPI do
         ]
       }
 
-      openstack_server_instance = double()
-      openstack_server_instance.should_receive(:addresses).and_return(valid_server_addresses)
+      expect(openstack_server_instance).to receive(:addresses).and_return(valid_server_addresses)
 
-      servers.should_receive(:get).and_return(openstack_server_instance)
-      openstack.should_receive(:servers).and_return(servers)
+      expect(servers).to receive(:get).and_return(openstack_server_instance)
+      expect(openstack).to receive(:servers).and_return(servers)
 
       result = subject.read_ssh_info(openstack, machine)
 
-      result[:port].should == 22
-      result[:host].should == "server2.example.org"
-      result[:username].should == "root"
+      expect(result).to eq({:port => 22, :username => "root", :host => "server2.example.org"})
     end
 
     it "uses the public network name from the config" do
-      provider_config.stub(:public_network_name => "my_custom_public_network_name")
-      machine.stub(:id => "anything")
-      machine.stub(:provider_config => provider_config)
+      expect(provider_config).to receive(:public_network_name).and_return("my_custom_public_network_name")
+      expect(machine).to receive(:id).at_least(:once).and_return("anything")
+
+      expect(machine).to receive(:provider_config).and_return(provider_config)
 
       valid_server_addresses = {
         "my_custom_public_network_name" => [
@@ -108,15 +103,14 @@ describe VagrantPlugins::OpenStack::Action::ReadSSHInfoFromAPI do
         ]
       }
 
-      openstack_server_instance = double()
-      openstack_server_instance.should_receive(:addresses).and_return(valid_server_addresses)
+      expect(openstack_server_instance).to receive(:addresses).and_return(valid_server_addresses)
 
-      servers.should_receive(:get).and_return(openstack_server_instance)
-      openstack.should_receive(:servers).and_return(servers)
+      expect(servers).to receive(:get).and_return(openstack_server_instance)
+      expect(openstack).to receive(:servers).and_return(servers)
 
       result = subject.read_ssh_info(openstack, machine)
 
-      result[:host].should == "server2.example.org"
+      expect(result).to eq({:port => 22, :username => "username", :host => "server2.example.org"})
     end
   end
-end
+end

data/spec/vagrant-openstack-cloud-provider/config_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 require "vagrant-openstack-cloud-provider/config"
+require "vagrant-openstack-cloud-provider/utils"
 
-describe VagrantPlugins::OpenStack::Config do
+RSpec.describe VagrantPlugins::OpenStack::Config do
   describe "defaults" do
     let(:vagrant_public_key) { Vagrant.source_root.join("keys/vagrant.pub") }
 
@@ -11,26 +12,29 @@ describe VagrantPlugins::OpenStack::Config do
       end
     end
 
-    its(:api_key)  { should be_nil }
-    its(:endpoint) { should be_nil }
-    its(:region) { should be_nil }
-    its(:flavor)   { should eq(/m1.tiny/) }
-    its(:image)    { should eq(/cirros/) }
-    its(:server_name) { should be_nil }
-    its(:username) { should be_nil }
-    its(:keypair_name) { should be_nil }
-    its(:ssh_username) { should be_nil }
-    its(:user_data) { should eq("") }
-    its(:metadata) { should eq({}) }
-    its(:public_network_name) { should eq("public") }
-    its(:networks) { should eq(["public"]) }
-    its(:tenant) { should be_nil }
-    its(:scheduler_hints) { should eq({}) }
-    its(:instance_build_timeout) { should eq(120) }
-    its(:report_progress) { should be_true }
+    it { is_expected.to have_attributes(api_key: nil) }
+    it { is_expected.to have_attributes(endpoint: nil) }
+    it { is_expected.to have_attributes(region: nil) }
+    it { is_expected.to have_attributes(flavor: /m1.tiny/) }
+    it { is_expected.to have_attributes(image: /cirros/) }
+    it { is_expected.to have_attributes(server_name: nil) }
+    it { is_expected.to have_attributes(username: nil) }
+    it { is_expected.to have_attributes(keypair_name: nil) }
+    it { is_expected.to have_attributes(ssh_username: nil) }
+    it { is_expected.to have_attributes(user_data: "") }
+    it { is_expected.to have_attributes(metadata: {}) }
+    it { is_expected.to have_attributes(public_network_name: "public") }
+    it { is_expected.to have_attributes(networks: ["public"]) }
+    it { is_expected.to have_attributes(tenant: nil) }
+    it { is_expected.to have_attributes(scheduler_hints: {}) }
+    it { is_expected.to have_attributes(instance_build_timeout: 120) }
+    it { is_expected.to have_attributes(instance_build_status_check_interval: 1) }
+    it { is_expected.to have_attributes(instance_ssh_timeout: 60) }
+    it { is_expected.to have_attributes(instance_ssh_check_interval: 2) }
+    it { is_expected.to have_attributes(report_progress: true) }
   end
 
-  describe "overriding defaults" do
+  describe "overriding defaults - strings" do
     [:api_key,
       :endpoint,
       :region,
@@ -45,12 +49,24 @@ describe VagrantPlugins::OpenStack::Config do
       :networks,
       :tenant,
       :scheduler_hints,
-      :instance_build_timeout,
       :report_progress].each do |attribute|
       it "should not default #{attribute} if overridden" do
         subject.send("#{attribute}=", "foo")
         subject.finalize!
-        subject.send(attribute).should == "foo"
+        expect(subject.send(attribute)).to eq("foo")
+      end
+    end
+  end
+
+  describe "overriding defaults - integers" do
+    [:instance_build_timeout,
+     :instance_build_status_check_interval,
+     :instance_ssh_timeout,
+     :instance_ssh_check_interval].each do |attribute|
+      it "should not default #{attribute} if overridden" do
+        subject.send("#{attribute}=", 12345)
+        subject.finalize!
+        expect(subject.send(attribute)).to eq(12345)
       end
     end
   end
@@ -81,5 +97,33 @@ describe VagrantPlugins::OpenStack::Config do
     context "the username" do
       it "should error if not given"
     end
+
+    context "the numeric values" do
+      [:instance_build_timeout,
+       :instance_build_status_check_interval,
+       :instance_ssh_timeout,
+       :instance_ssh_check_interval].each do |attribute|
+        it "should cast #{attribute} to an int" do
+          subject.send("#{attribute}=", "100")
+          subject.finalize!
+          expect(subject.send(attribute)).to eq(100)
+        end
+        it "should raise when given a wrong value" do
+          expect { subject.send("#{attribute}=", "huhu") }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    context "non-null positive integers" do
+      [:instance_build_timeout,
+       :instance_build_status_check_interval,
+       :instance_ssh_timeout,
+       :instance_ssh_check_interval].each do |attribute|
+        it "should cast #{attribute} to an int" do
+          expect { subject.send("#{attribute}=", "0") }.to raise_error(InvalidValue)
+          expect { subject.send("#{attribute}=", -1) }.to raise_error(InvalidValue)
+        end
+      end
+    end
   end
 end

data/vagrant-openstack-cloud-provider.gemspec

@@ -14,9 +14,10 @@ Gem::Specification.new do |gem|
   gem.homepage      = "http://www.vagrantup.com"
 
   gem.add_runtime_dependency "fog", "~> 1.22"
+  gem.add_runtime_dependency "promise", "~> 0.3.1"
 
   gem.add_development_dependency "rake", '< 11.0'
-  gem.add_development_dependency "rspec", "~> 2.13.0"
+  gem.add_development_dependency "rspec", "~> 3.5.0"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-openstack-cloud-provider
 version: !ruby/object:Gem::Version
-  version: 1.1.8
+  version: 1.1.9
 platform: ruby
 authors:
 - Mathieu Mitchell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-18 00:00:00.000000000 Z
+date: 2017-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.22'
+- !ruby/object:Gem::Dependency
+  name: promise
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -44,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.13.0
+        version: 3.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.13.0
+        version: 3.5.0
 description: Vagrant provider for OpenStack clouds.
 email:
 - mat128@gmail.com
@@ -85,10 +99,12 @@ files:
 - lib/vagrant-openstack-cloud-provider/errors.rb
 - lib/vagrant-openstack-cloud-provider/plugin.rb
 - lib/vagrant-openstack-cloud-provider/provider.rb
+- lib/vagrant-openstack-cloud-provider/utils.rb
 - lib/vagrant-openstack-cloud-provider/version.rb
 - lib/vagrant-openstack.rb
 - locales/en.yml
 - spec/spec_helper.rb
+- spec/vagrant-openstack-cloud-provider/action/connect_openstack_spec.rb
 - spec/vagrant-openstack-cloud-provider/action/create_server_spec.rb
 - spec/vagrant-openstack-cloud-provider/action/read_ssh_info_spec.rb
 - spec/vagrant-openstack-cloud-provider/config_spec.rb
@@ -119,6 +135,7 @@ specification_version: 4
 summary: Enables Vagrant to manage machines in OpenStack Cloud.
 test_files:
 - spec/spec_helper.rb
+- spec/vagrant-openstack-cloud-provider/action/connect_openstack_spec.rb
 - spec/vagrant-openstack-cloud-provider/action/create_server_spec.rb
 - spec/vagrant-openstack-cloud-provider/action/read_ssh_info_spec.rb
 - spec/vagrant-openstack-cloud-provider/config_spec.rb