vagrant-openstack-provider 0.4.1 → 0.5.0

data/lib/vagrant-openstack-provider/plugin.rb

@@ -6,8 +6,8 @@ end
 
 # This is a sanity check to make sure no one is attempting to install
 # this into an early Vagrant version.
-if Vagrant::VERSION < '1.1.0'
-  fail 'Openstack Cloud provider is only compatible with Vagrant 1.1+'
+if Vagrant::VERSION < '1.4.0'
+  fail 'Openstack Cloud provider is only compatible with Vagrant 1.4+'
 end
 
 module VagrantPlugins
@@ -23,7 +23,7 @@ module VagrantPlugins
         Config
       end
 
-      provider(:openstack) do
+      provider(:openstack, box_optional: true) do
         # Setup some things
         Openstack.init_i18n
         Openstack.init_logging

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module Openstack
+    class Utils
+      def initialize
+        @logger = Log4r::Logger.new('vagrant_openstack::action::config_resolver')
+      end
+
+      def get_ip_address(env)
+        return env[:machine].provider_config.floating_ip unless env[:machine].provider_config.floating_ip.nil?
+        details = env[:openstack_client].nova.get_server_details(env, env[:machine].id)
+        details['addresses'].each do |network|
+          network[1].each do |network_detail|
+            return network_detail['addr'] if network_detail['OS-EXT-IPS:type'] == 'floating'
+          end
+        end
+        return details['addresses'].first[1][0]['addr'] if details['addresses'].size == 1 && details['addresses'].first[1].size == 1
+        fail Errors::UnableToResolveIP
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Openstack
-    VERSION = '0.4.1'
+    VERSION = '0.5.0'
   end
 end

data/locales/en.yml

@@ -44,6 +44,10 @@ en:
       Warning! The Openstack provider doesn't support any of the Vagrant
       high-level network configurations (`config.vm.network`). They
       will be silently ignored.
+    warn_network_identifier_is_assumed_to_be_an_id: |-
+      As Neutron endpoint is not available, the identifier '%{network}' is assumed to be an id (not a name).
+    warn_volume_identifier_is_assumed_to_be_an_id: |-
+      As Cinder endpoint is not available, the identifier '%{volume}' is assumed to be an id (not a name).
 
     config:
       password_required: |-
@@ -68,6 +72,8 @@ en:
         standard vagrant configuration option `config.ssh.username` instead
       ssh_username_required: |-
         vagrant standard configuration option `ssh.username` is required
+      invalid_value_for_parameter: |-
+        Invalid value '%{value}' for parameter '%{parameter}'
 
     errors:
       default: |-
@@ -108,12 +114,26 @@ en:
         SSH server anavailable on instance %{host}. You should maybe increase the timeout value which currently is %{timeout} second(s).
       no_arg_required_for_command: |-
         Command '%{cmd}' does not required any argument.
+      unrecognized_arg_for_command: |-
+        Argument '%{arg}' unrecognized for command '%{cmd}'.
       unable_to_resolve_floating_ip: |-
         Vagrant was unable to resolve a floating ip to communicate with your OpenStack instance. Please specify in your Vagrantfile either `floating_ip` or `floating_ip_pool`.
       unable_to_resolve_ip: |-
         Vagrant was unable to resolve a valid ip to ssh on your OpenStack instance.
       unable_to_resolve_ssh_key: |-
         Vagrant was unable to resolve a valid ssh key to connect to your OpenStack instance. Please specify in your Vagrantfile either `public_key_path` or `keypair_name`.
+      invalid_network_format: |-
+        Network '%{network}' is not valid.
+      unresolved_network: |-
+        No matching network with id or name '%{network}'
+      unresolved_network_id: |-
+        No matching network with id '%{id}'
+      unresolved_network_name: |-
+        No matching network with name '%{name}'
+      conflict_network_name_id: |-
+        One (and only one) of 'id' or 'name' must be specified in network definition : %{network}
+      multiple_network_name: |-
+        More than one network exists with name '%{name}'. In this case you can't use name in network definition. Please, use id instead.
       invalid_volume_format: |-
         Volume '%{volume}' is not valid.
       unresolved_volume: |-
@@ -125,13 +145,25 @@ en:
       conflict_volume_name_id: |-
         One (and only one) of 'id' or 'name' must be specified in volume definition : %{volume}
       multiple_volume_name: |-
-        More than one volume exists with name '%{name}'. In the case you can't use name in volume definition. Please, use id instead.
+        More than one volume exists with name '%{name}'. In this case you can't use name in volume definition. Please, use id instead.
       missing_boot_option: |-
         Either 'image' or 'volume_boot' configuration must be provided
       conflict_boot_option: |-
         Only one of 'image' and 'volume_boot' configuration must be provided
       ssh_username_missing: |-
         Vagrant was unable to resolve which ssh username to use to connect to the machine. Please provide config parameter `ssh.username`
+      instance_not_found: |-
+        Vagrant was unable to find the OpenStack instance used for your vagrant machine.
+        This can happen when the instance has been deleted via OpenStack APIs or OpenStack
+        Dashboard instead of using vagrant commands.
+        We recommend using the command `vagrant openstack reset` to reset
+        vagrant to a clear state
+      nerwork_service_unavailable: |-
+        Neutron service endpoint is not available, thus there is not way to retrieve
+        network id from its name. You have to provide only ids in your Vagrantfile.
+      volume_service_unavailable: |-
+        Cinder service endpoint is not available, thus there is not way to retrieve
+        volume id from its name. You have to provide only ids in your Vagrantfile.
 
     states:
       short_active: |-
@@ -233,3 +265,5 @@ en:
         List floating IP and floating IP pools
       volume_list_synopsis : |-
         List existing volumes
+      reset : |-
+        Reset Vagrant OpenStack provider to a clear state

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

@@ -1,4 +1,5 @@
 require 'vagrant-openstack-provider/spec_helper'
+require 'ostruct'
 require 'sshkey'
 
 include VagrantPlugins::Openstack::Action
@@ -6,25 +7,18 @@ include VagrantPlugins::Openstack::HttpUtils
 include VagrantPlugins::Openstack::Domain
 
 describe VagrantPlugins::Openstack::Action::CreateServer do
-  include FakeFS::SpecHelpers
 
   let(:config) do
     double('config').tap do |config|
-      config.stub(:openstack_auth_url) { 'http://keystoneAuthV2' }
-      config.stub(:openstack_compute_url) { nil }
-      config.stub(:openstack_network_url) { nil }
       config.stub(:tenant_name) { 'testTenant' }
-      config.stub(:username) { 'username' }
-      config.stub(:password) { 'password' }
       config.stub(:server_name) { 'testName' }
-      config.stub(:availability_zone) { 'AZ-01' }
-      config.stub(:floating_ip) { nil }
-      config.stub(:floating_ip_pool) { nil }
-      config.stub(:floating_ip_pool_always_allocate) { false }
-      config.stub(:keypair_name) { nil }
-      config.stub(:public_key_path) { nil }
-      config.stub(:networks) { nil }
-      config.stub(:volumes) { nil }
+      config.stub(:image) { 'ubuntu' }
+      config.stub(:volume_boot) { nil }
+      config.stub(:availability_zone) { nil }
+      config.stub(:scheduler_hints) { nil }
+      config.stub(:security_groups) { nil }
+      config.stub(:user_data) { nil }
+      config.stub(:metadata) { nil }
     end
   end
 
@@ -35,13 +29,6 @@ describe VagrantPlugins::Openstack::Action::CreateServer do
     end
   end
 
-  let(:ssh_key) do
-    double('ssh_key').tap do |key|
-      key.stub(:ssh_public_key) { 'ssh public key' }
-      key.stub(:private_key) { 'private key' }
-    end
-  end
-
   let(:flavor) do
     double('flavor').tap do |flavor|
       flavor.stub(:name) { 'flavor_name'  }
@@ -49,36 +36,8 @@ describe VagrantPlugins::Openstack::Action::CreateServer do
     end
   end
 
-  let(:neutron) do
-    double('neutron').tap do |neutron|
-      neutron.stub(:get_private_networks).with(anything) do
-        [Item.new('net-id-1', 'net-1'), Item.new('net-id-2', 'net-2')]
-      end
-    end
-  end
-
   let(:nova) do
-    double('nova').tap do |nova|
-      nova.stub(:get_all_floating_ips).with(anything) do
-        [FloatingIP.new('80.81.82.83', 'pool-1', nil), FloatingIP.new('30.31.32.33', 'pool-2', '1234')]
-      end
-    end
-  end
-
-  let(:cinder) do
-    double('cinder').tap do |cinder|
-      cinder.stub(:get_all_volumes).with(anything) do
-        [Volume.new('001', 'vol-01', '1', 'available', 'true', nil, nil),
-         Volume.new('002', 'vol-02', '2', 'available', 'true', nil, nil),
-         Volume.new('003', 'vol-03', '3', 'available', 'true', nil, nil),
-         Volume.new('004', 'vol-04', '4', 'available', 'false', nil, nil),
-         Volume.new('005', 'vol-05', '5', 'available', 'false', nil, nil),
-         Volume.new('006', 'vol-06', '6', 'available', 'false', nil, nil),
-         Volume.new('007', 'vol-07-08', '6', 'available', 'false', nil, nil),
-         Volume.new('008', 'vol-07-08', '6', 'available', 'false', nil, nil)]
-
-      end
-    end
+    double('nova')
   end
 
   let(:env) do
@@ -86,18 +45,47 @@ describe VagrantPlugins::Openstack::Action::CreateServer do
       env[:ui] = double('ui')
       env[:ui].stub(:info).with(anything)
       env[:machine] = double('machine')
-      env[:machine].stub(:provider_config) { config }
-      env[:machine].stub(:data_dir) { '/data/dir' }
+      env[:machine] = OpenStruct.new.tap do |m|
+        m.provider_config = config
+        m.id = nil
+      end
       env[:openstack_client] = double('openstack_client')
-      env[:openstack_client].stub(:neutron) { neutron }
       env[:openstack_client].stub(:nova) { nova }
-      env[:openstack_client].stub(:cinder) { cinder }
+    end
+  end
+
+  let(:resolver) do
+    double('resolver').tap do |r|
+      r.stub(:resolve_flavor).with(anything) do
+        Flavor.new('flavor-01', 'small', nil, nil, nil)
+      end
+      r.stub(:resolve_image).with(anything) do
+        Item.new('image-01', 'ubuntu')
+      end
+      r.stub(:resolve_volume_boot).with(anything) { 'ubuntu-drive' }
+      r.stub(:resolve_networks).with(anything) { 'net-001' }
+      r.stub(:resolve_volumes).with(anything) do
+        [{ id: 'vol-01', device: nil }]
+      end
+      r.stub(:resolve_keypair).with(anything) { 'key' }
+      r.stub(:resolve_floating_ip).with(anything) { '1.2.3.4' }
+      r.stub(:resolve_security_groups).with(anything) do
+        [{ name: 'group1' }, { name: 'group2' }]
+      end
+    end
+  end
+
+  let(:utils) do
+    double('utils').tap do |u|
+      u.stub(:get_ip_address) { '1.2.3.4' }
     end
   end
 
   before :each do
     CreateServer.send(:public, *CreateServer.private_instance_methods)
-    @action = CreateServer.new(nil, nil)
+    app = double('app')
+    app.stub(:call).with(anything)
+    @action = CreateServer.new(app, nil, resolver, utils)
   end
 
   describe 'call' do
@@ -115,6 +103,21 @@ describe VagrantPlugins::Openstack::Action::CreateServer do
         expect { @action.call(env) }.to raise_error Errors::MissingBootOption
       end
     end
+    context 'with full options' do
+      it 'works' do
+        allow(@action).to receive(:create_server).and_return('45678')
+        allow(@action).to receive(:assign_floating_ip).and_return('1.2.3.4')
+        allow(@action).to receive(:waiting_for_server_to_be_built)
+        allow(@action).to receive(:attach_volumes)
+        allow(@action).to receive(:waiting_for_server_to_be_reachable)
+
+        expect(@action).to receive(:waiting_for_server_to_be_built).with(env, '45678')
+        expect(@action).to receive(:assign_floating_ip).with(env, '45678').and_return('1.2.3.4')
+        expect(@action).to receive(:attach_volumes).with(env, '45678', [{ id: 'vol-01', device: nil }])
+
+        @action.call(env)
+      end
+    end
   end
 
   describe 'create_server' do
@@ -126,7 +129,7 @@ describe VagrantPlugins::Openstack::Action::CreateServer do
         flavor_ref: flavor.id,
         image_ref: image.id,
         volume_boot: nil,
-        networks: ['test-networks'],
+        networks: [{ uuid: 'test-networks-1' }, { uuid: 'test-networks-2', fixed_ip: '1.2.3.4' }],
         keypair: 'test-keypair',
         availability_zone: 'test-az',
         scheduler_hints: 'test-sched-hints',
@@ -138,7 +141,7 @@ describe VagrantPlugins::Openstack::Action::CreateServer do
         options = {
           flavor: flavor,
           image: image,
-          networks: ['test-networks'],
+          networks: [{ uuid: 'test-networks-1' }, { uuid: 'test-networks-2', fixed_ip: '1.2.3.4' }],
           volumes: [{ id: '001', device: :auto }, { id: '002', device: '/dev/vdc' }],
           keypair_name: 'test-keypair',
           availability_zone: 'test-az',
@@ -151,333 +154,83 @@ describe VagrantPlugins::Openstack::Action::CreateServer do
         expect(@action.create_server(env, options)).to eq '1234'
       end
     end
-  end
-
-  describe 'resolve_floating_ip' do
-    context 'with config.floating_ip specified' do
-      it 'return the specified floating ip' do
-        config.stub(:floating_ip) { '80.80.80.80' }
-        @action.resolve_floating_ip(env).should eq('80.80.80.80')
-      end
-    end
-
-    context 'with config.floating_pool specified' do
-      context 'if any ip in the same pool is available' do
-        context 'with config.floating_pool_always_allocate true' do
-          it 'allocate a new floating_ip from the pool' do
-            config.stub(:floating_ip_pool_always_allocate) { true }
-            nova.stub(:get_all_floating_ips).with(anything) do
-              [FloatingIP.new('80.81.82.84', 'pool-1', '1234'),
-               FloatingIP.new('80.81.82.83', 'pool-1', nil)]
-            end
-            nova.stub(:allocate_floating_ip).with(env, 'pool-1') do
-              FloatingIP.new('80.81.82.84', 'pool-1', nil)
-            end
-            config.stub(:floating_ip_pool) { 'pool-1' }
-            @action.resolve_floating_ip(env).should eq('80.81.82.84')
-          end
-        end
-
-        context 'with config.floating_pool_always_allocate false' do
-          it 'return one of the available ips' do
-            config.stub(:floating_ip_pool_always_allocate) { false }
-            nova.stub(:get_all_floating_ips).with(anything) do
-              [FloatingIP.new('80.81.82.84', 'pool-1', '1234'),
-               FloatingIP.new('80.81.82.83', 'pool-1', nil)]
-            end
-            config.stub(:floating_ip_pool) { 'pool-1' }
-            @action.resolve_floating_ip(env).should eq('80.81.82.83')
-          end
-        end
-      end
-
-      context 'if no ip in the same pool is available' do
-        it 'allocate a new floating_ip from the pool' do
-          nova.stub(:get_all_floating_ips).with(anything) do
-            [FloatingIP.new('80.81.82.83', 'pool-1', '1234')]
-          end
-          nova.stub(:allocate_floating_ip).with(env, 'pool-1') do
-            FloatingIP.new('80.81.82.84', 'pool-1', nil)
-          end
-          config.stub(:floating_ip_pool) { 'pool-1' }
-          @action.resolve_floating_ip(env).should eq('80.81.82.84')
-        end
-      end
-    end
-
-    context 'with neither floating_ip nor floating_ip_pool' do
-      context 'if any ip is not associated with an instance' do
-        it 'return the available ip in the list of floating ips' do
-          nova.stub(:get_all_floating_ips).with(anything) do
-            [FloatingIP.new('80.81.82.84', 'pool-1', '1234'), FloatingIP.new('80.81.82.83', 'pool-1', nil)]
-          end
-          @action.resolve_floating_ip(env).should eq('80.81.82.83')
-        end
-      end
-
-      context 'if all ips are already associated with an instance' do
-        it 'fails with an UnableToResolveFloatingIP error' do
-          nova.stub(:get_all_floating_ips).with(anything) do
-            [FloatingIP.new('80.81.82.84', 'pool-1', '1234'), FloatingIP.new('80.81.82.83', 'pool-1', '2345')]
-          end
-          expect { @action.resolve_floating_ip(env) }.to raise_error(Errors::UnableToResolveFloatingIP)
+    context 'with minimal configuration and a single network' do
+      it 'calls nova' do
+        config.stub(:server_name) { nil }
+        nova.stub(:create_server).with(
+          env,
+          name: nil,
+          flavor_ref: flavor.id,
+          image_ref: image.id,
+          volume_boot: nil,
+          networks: [{ uuid: 'test-networks-1' }],
+          keypair: 'test-keypair',
+          availability_zone: nil,
+          scheduler_hints: nil,
+          security_groups: [],
+          user_data: nil,
+          metadata: nil) do '1234'
         end
-      end
-    end
-  end
-
-  describe 'resolve_keypair' do
-    context 'with keypair_name provided' do
-      it 'return the provided keypair_name' do
-        config.stub(:keypair_name) { 'my-keypair' }
-        @action.resolve_keypair(env).should eq('my-keypair')
-      end
-    end
-
-    context 'with keypair_name and public_key_path provided' do
-      it 'return the provided keypair_name' do
-        config.stub(:keypair_name) { 'my-keypair' }
-        config.stub(:public_key_path) { '/path/to/key' }
-        @action.resolve_keypair(env).should eq('my-keypair')
-      end
-    end
-
-    context 'with public_key_path provided' do
-      it 'return the keypair_name created into nova' do
-        config.stub(:public_key_path) { '/path/to/key' }
-        nova.stub(:import_keypair_from_file).with(env, '/path/to/key') { 'my-keypair-imported' }
-        @action.resolve_keypair(env).should eq('my-keypair-imported')
-      end
-    end
-
-    context 'with no keypair_name and no public_key_path provided' do
-      it 'generates a new keypair and return the keypair name imported into nova' do
-        config.stub(:keypair_name) { nil }
-        config.stub(:public_key_path) { nil }
-        @action.stub(:generate_keypair) { 'my-keypair-imported' }
-        @action.resolve_keypair(env).should eq('my-keypair-imported')
-      end
-    end
-  end
-
-  describe 'generate_keypair' do
-    it 'returns a generated keypair name imported into nova' do
-      nova.stub(:import_keypair) { 'my-keypair-imported' }
-      SSHKey.stub(:generate) { ssh_key }
-      File.should_receive(:write).with('/data/dir/my-keypair-imported', 'private key')
-      @action.generate_keypair(env).should eq('my-keypair-imported')
-    end
-  end
-
-  describe 'resolve_networks' do
-
-    context 'with only ids of existing networks' do
-      it 'return the ids array' do
-        config.stub(:networks) { %w(net-id-1 net-id-2) }
-        @action.resolve_networks(env).should eq(%w(net-id-1 net-id-2))
-      end
-    end
-
-    context 'with only names of existing networks' do
-      it 'return the ids array' do
-        config.stub(:networks) { %w(net-1 net-2) }
-        @action.resolve_networks(env).should eq(%w(net-id-1 net-id-2))
-      end
-    end
 
-    context 'with only names and ids of existing networks' do
-      it 'return the ids array' do
-        config.stub(:networks) { %w(net-1 net-id-2) }
-        @action.resolve_networks(env).should eq(%w(net-id-1 net-id-2))
-      end
-    end
-
-    context 'with not existing networks' do
-      it 'return the ids array' do
-        config.stub(:networks) { %w(net-1 net-id-3) }
-        expect { @action.resolve_networks(env) }.to raise_error
-      end
-    end
-
-    context 'with no network returned by neutron and no network specified in vagrant provider' do
-      it 'return the ids array' do
-        neutron.stub(:get_private_networks).with(anything) { [] }
-        config.stub(:networks) { [] }
-        @action.resolve_networks(env).should eq([])
-      end
-    end
+        options = {
+          flavor: flavor,
+          image: image,
+          networks: [{ uuid: 'test-networks-1' }],
+          volumes: [],
+          keypair_name: 'test-keypair',
+          availability_zone: nil,
+          scheduler_hints: nil,
+          security_groups: [],
+          user_data: nil,
+          metadata: nil
+        }
 
-    context 'with no network returned by neutron and one network specified in vagrant provider' do
-      it 'return the ids array' do
-        neutron.stub(:get_private_networks).with(anything) { [] }
-        config.stub(:networks) { ['net-id-1'] }
-        expect { @action.resolve_networks(env) }.to raise_error
+        expect(@action.create_server(env, options)).to eq '1234'
       end
     end
-
   end
 
-  describe 'resolve_volume_boot' do
-    context 'with string volume id' do
-      it 'returns normalized volume' do
-        config.stub(:volume_boot) { '001' }
-        expect(@action.resolve_volume_boot(env)).to eq id: '001', device: 'vda'
-      end
-    end
-
-    context 'with string volume name' do
-      it 'returns normalized volume' do
-        config.stub(:volume_boot) { 'vol-01' }
-        expect(@action.resolve_volume_boot(env)).to eq id: '001', device: 'vda'
-      end
-    end
-
-    context 'with hash volume id' do
-      it 'returns normalized volume' do
-        config.stub(:volume_boot) { { id: '001' } }
-        expect(@action.resolve_volume_boot(env)).to eq id: '001', device: 'vda'
-      end
-    end
-
-    context 'with hash volume name' do
-      it 'returns normalized volume' do
-        config.stub(:volume_boot) { { name: 'vol-01' } }
-        expect(@action.resolve_volume_boot(env)).to eq id: '001', device: 'vda'
-      end
-    end
-
-    context 'with hash volume id and device' do
-      it 'returns normalized volume' do
-        config.stub(:volume_boot) { { id: '001', device: 'vdb' } }
-        expect(@action.resolve_volume_boot(env)).to eq id: '001', device: 'vdb'
-      end
-    end
-
-    context 'with hash volume name and device' do
-      it 'returns normalized volume' do
-        config.stub(:volume_boot) { { name: 'vol-01', device: 'vdb' } }
-        expect(@action.resolve_volume_boot(env)).to eq id: '001', device: 'vdb'
-      end
-    end
-
-    context 'with empty hash' do
-      it 'raises an error' do
-        config.stub(:volume_boot) { {} }
-        expect { @action.resolve_volume_boot(env) }.to raise_error(Errors::ConflictVolumeNameId)
-      end
-    end
-
-    context 'with invalid volume object' do
-      it 'raises an error' do
-        config.stub(:volume_boot) { 1 }
-        expect { @action.resolve_volume_boot(env) }.to raise_error(Errors::InvalidVolumeObject)
+  describe 'waiting_for_server_to_be_built' do
+    context 'when server is not yet active' do
+      it 'become active after one retry' do
+        nova.stub(:get_server_details).and_return({ 'status' => 'BUILD' }, { 'status' => 'ACTIVE' })
+        nova.should_receive(:get_server_details).with(env, 'server-01').exactly(2).times
+        @action.waiting_for_server_to_be_built(env, 'server-01', 1, 5)
       end
-    end
-
-    context 'with hash containing a bad id' do
-      it 'raises an error' do
-        config.stub(:volume_boot) { { id: 'not-exist' } }
-        expect { @action.resolve_volume_boot(env) }.to raise_error(Errors::UnresolvedVolumeId)
-      end
-    end
-
-    context 'with hash containing a bad name' do
-      it 'raises an error' do
-        config.stub(:volume_boot) { { name: 'not-exist' } }
-        expect { @action.resolve_volume_boot(env) }.to raise_error(Errors::UnresolvedVolumeName)
-      end
-    end
-
-    context 'with hash containing both id and name' do
-      it 'raises an error' do
-        config.stub(:volume_boot) { { id: '001', name: 'vol-01' } }
-        expect { @action.resolve_volume_boot(env) }.to raise_error(Errors::ConflictVolumeNameId)
-      end
-    end
-
-    context 'with hash containing a name matching more than one volume' do
-      it 'raises an error' do
-        config.stub(:volume_boot) { { name: 'vol-07-08' } }
-        expect { @action.resolve_volume_boot(env) }.to raise_error(Errors::MultipleVolumeName)
+      it 'timeout before the server become active' do
+        nova.stub(:get_server_details).and_return({ 'status' => 'BUILD' }, { 'status' => 'BUILD' })
+        nova.should_receive(:get_server_details).with(env, 'server-01').at_least(2).times
+        expect { @action.waiting_for_server_to_be_built(env, 'server-01', 1, 3) }.to raise_error Timeout::Error
       end
     end
   end
 
-  describe 'resolve_volumes' do
-    context 'with volume attached in all possible ways' do
-      it 'returns normalized volume list' do
-
-        config.stub(:volumes) do
-          ['001',
-           'vol-02',
-           { id: '003', device: '/dev/vdz' },
-           { name: 'vol-04', device: '/dev/vdy' },
-           { name: 'vol-05' },
-           { id: '006' }]
-        end
-
-        expect(@action.resolve_volumes(env)).to eq [{ id: '001', device: nil },
-                                                    { id: '002', device: nil },
-                                                    { id: '003', device: '/dev/vdz' },
-                                                    { id: '004', device: '/dev/vdy' },
-                                                    { id: '005', device: nil },
-                                                    { id: '006', device: nil }]
-      end
-    end
-
-    context 'with invalid volume object' do
-      it 'raises an error' do
-        config.stub(:volumes) { [1] }
-        expect { @action.resolve_volumes(env) }.to raise_error(Errors::InvalidVolumeObject)
-      end
-    end
-
-    context 'with string that is neither an id nor name matching a volume' do
-      it 'raises an error' do
-        config.stub(:volumes) { ['not-exist'] }
-        expect { @action.resolve_volumes(env) }.to raise_error(Errors::UnresolvedVolume)
-      end
-    end
-
-    context 'with hash containing a bad id' do
-      it 'raises an error' do
-        config.stub(:volumes) { [{ id: 'not-exist' }] }
-        expect { @action.resolve_volumes(env) }.to raise_error(Errors::UnresolvedVolumeId)
-      end
-    end
-
-    context 'with hash containing a bad name' do
-      it 'raises an error' do
-        config.stub(:volumes) { [{ name: 'not-exist' }] }
-        expect { @action.resolve_volumes(env) }.to raise_error(Errors::UnresolvedVolumeName)
+  describe 'assign_floating_ip' do
+    context 'When resolve correctly floating ip' do
+      it 'calls nova to assign floating ip' do
+        resolver.stub(:resolve_floating_ip).and_return '1.2.3.4'
+        nova.stub(:add_floating_ip)
+        expect(resolver).to receive(:resolve_floating_ip).with(env)
+        expect(nova).to receive(:add_floating_ip).with(env, 'server-01', '1.2.3.4')
+        @action.assign_floating_ip(env, 'server-01')
       end
     end
-
-    context 'with empty hash' do
-      it 'raises an error' do
-        config.stub(:volumes) { [{}] }
-        expect { @action.resolve_volumes(env) }.to raise_error(Errors::ConflictVolumeNameId)
-      end
-    end
-
-    context 'with hash containing both id and name' do
-      it 'raises an error' do
-        config.stub(:volumes) { [{ id: '001', name: 'vol-01' }] }
-        expect { @action.resolve_volumes(env) }.to raise_error(Errors::ConflictVolumeNameId)
+    context 'When unable to resolve floating ip' do
+      it 'does not fail' do
+        resolver.stub(:resolve_floating_ip).and_raise Errors::UnableToResolveFloatingIP
+        nova.stub(:add_floating_ip)
+        expect(resolver).to receive(:resolve_floating_ip).with(env)
+        expect(nova).to_not receive(:add_floating_ip)
+        @action.assign_floating_ip(env, 'server-01')
       end
     end
-
-    context 'with hash containing both id and name' do
-      it 'raises an error' do
-        config.stub(:volumes) { [{ id: '001', name: 'vol-01' }] }
-        expect { @action.resolve_volumes(env) }.to raise_error(Errors::ConflictVolumeNameId)
-      end
-    end
-
-    context 'with hash containing a name matching more than one volume' do
-      it 'raises an error' do
-        config.stub(:volumes) { [{ name: 'vol-07-08' }] }
-        expect { @action.resolve_volumes(env) }.to raise_error(Errors::MultipleVolumeName)
+    context 'When neither floating ip nor floating ip pool is configured' do
+      it 'does nothing' do
+        resolver.stub(:resolve_floating_ip).and_return nil
+        nova.stub(:add_floating_ip)
+        expect(resolver).to receive(:resolve_floating_ip).with(env)
+        expect(nova).to_not receive(:add_floating_ip)
+        @action.assign_floating_ip(env, 'server-01')
       end
     end
   end