vagrant-openstack-provider 0.4.1 → 0.5.0

data/spec/vagrant-openstack-provider/client/keystone_spec.rb

@@ -47,7 +47,7 @@ describe VagrantPlugins::Openstack::KeystoneClient do
     end
 
     before :each do
-      @keystone_client = VagrantPlugins::Openstack::KeystoneClient.instance
+      @keystone_client = VagrantPlugins::Openstack.keystone
     end
 
     context 'with good credentials' do

data/spec/vagrant-openstack-provider/client/neutron_spec.rb

@@ -14,7 +14,7 @@ describe VagrantPlugins::Openstack::NeutronClient do
     session.token = '123456'
     session.project_id = 'a1b2c3'
     session.endpoints = { network: 'http://neutron' }
-    @neutron_client = VagrantPlugins::Openstack::NeutronClient.instance
+    @neutron_client = VagrantPlugins::Openstack.neutron
   end
 
   describe 'get_private_networks' do
@@ -51,6 +51,42 @@ describe VagrantPlugins::Openstack::NeutronClient do
     end
   end
 
+  describe 'get_all_networks' do
+    context 'with token' do
+      it 'returns all networks for project in session' do
+
+        stub_request(:get, 'http://neutron/networks')
+            .with(
+              headers:
+              {
+                'Accept' => 'application/json',
+                'X-Auth-Token' => '123456'
+              })
+            .to_return(
+              status: 200,
+              body: '
+                {
+                  "networks": [
+                    { "name": "PublicNetwork", "tenant_id": "admin-tenant-id", "id": "net-pub" },
+                    { "name": "net1", "tenant_id": "a1b2c3", "id": "net-1" },
+                    { "name": "net2", "tenant_id": "a1b2c3", "id": "net-2" }
+                  ]
+                }
+              ')
+
+        networks = @neutron_client.get_all_networks(env)
+
+        expect(networks.length).to eq(3)
+        expect(networks[0].id).to eq('net-pub')
+        expect(networks[0].name).to eq('PublicNetwork')
+        expect(networks[1].id).to eq('net-1')
+        expect(networks[1].name).to eq('net1')
+        expect(networks[2].id).to eq('net-2')
+        expect(networks[2].name).to eq('net2')
+      end
+    end
+  end
+
   describe 'get_api_version_list' do
     context 'basic' do
       it 'returns version list' do

data/spec/vagrant-openstack-provider/client/nova_spec.rb

@@ -39,7 +39,29 @@ describe VagrantPlugins::Openstack::NovaClient do
     session.token = '123456'
     session.project_id = 'a1b2c3'
     session.endpoints = { compute: 'http://nova/a1b2c3' }
-    @nova_client = VagrantPlugins::Openstack::NovaClient.instance
+    @nova_client = VagrantPlugins::Openstack.nova
+  end
+
+  describe 'instance_exists' do
+    context 'instance not found' do
+      it 'raise an InstanceNotFound error' do
+        stub_request(:post, 'http://nova/a1b2c3/servers/o1o2o3/action')
+            .with(
+              body: '{"os-start":null}',
+              headers:
+              {
+                'Accept' => 'application/json',
+                'Content-Type' => 'application/json',
+                'X-Auth-Token' => '123456'
+              })
+            .to_return(
+              status: 404,
+              body: '{"itemNotFound": {"message": "Instance could not be found", "code": 404}}')
+
+        expect { @nova_client.start_server(env, 'o1o2o3') }.to raise_error(VagrantPlugins::Openstack::Errors::InstanceNotFound)
+
+      end
+    end
   end
 
   describe 'get_all_flavors' do
@@ -119,7 +141,7 @@ describe VagrantPlugins::Openstack::NovaClient do
           stub_request(:post, 'http://nova/a1b2c3/servers')
               .with(
                 body: '{"server":{"name":"inst","imageRef":"img","flavorRef":"flav","key_name":"key",'\
-                '"security_groups":["default"],"user_data":"user_data_test","metadata":"metadata_test"},'\
+                '"security_groups":[{"name":"default"}],"user_data":"dXNlcl9kYXRhX3Rlc3Q=\n","metadata":"metadata_test"},'\
                 '"scheduler_hints":"sched_hints_test"}',
                 headers:
                 {
@@ -136,7 +158,7 @@ describe VagrantPlugins::Openstack::NovaClient do
             flavor_ref: 'flav',
             networks: nil,
             keypair: 'key',
-            security_groups: ['default'],
+            security_groups: [{ name: 'default' }],
             user_data: 'user_data_test',
             metadata: 'metadata_test',
             scheduler_hints: 'sched_hints_test')
@@ -145,7 +167,7 @@ describe VagrantPlugins::Openstack::NovaClient do
         end
       end
 
-      context 'with one two networks' do
+      context 'with two networks' do
         it 'returns new instance id' do
 
           stub_request(:post, 'http://nova/a1b2c3/servers')
@@ -159,7 +181,8 @@ describe VagrantPlugins::Openstack::NovaClient do
                   })
           .to_return(status: 202, body: '{ "server": { "id": "o1o2o3" } }')
 
-          instance_id = @nova_client.create_server(env, name: 'inst', image_ref: 'img', flavor_ref: 'flav', networks: %w(net1 net2), keypair: 'key')
+          instance_id = @nova_client.create_server(env, name: 'inst', image_ref: 'img', flavor_ref: 'flav',
+                                                        networks: [{ uuid: 'net1' }, { uuid: 'net2' }], keypair: 'key')
 
           expect(instance_id).to eq('o1o2o3')
         end
@@ -230,7 +253,7 @@ describe VagrantPlugins::Openstack::NovaClient do
       it 'returns newly created keypair name' do
         File.should_receive(:exist?).with(filename).and_return(true)
         File.should_receive(:open).with(filename).and_return(file)
-        Kernel.stub!(:rand).and_return(2_036_069_739_008)
+        Kernel.stub(:rand).and_return(2_036_069_739_008)
 
         stub_request(:post, 'http://nova/a1b2c3/os-keypairs')
             .with(
@@ -413,7 +436,8 @@ describe VagrantPlugins::Openstack::NovaClient do
 
         floating_ips = @nova_client.get_all_floating_ips(env)
 
-        expect(floating_ips).to have(2).items
+        expect(floating_ips).not_to be_nil
+        expect(floating_ips.size).to eq(2)
         expect(floating_ips[0].ip).to eql('185.39.216.45')
         expect(floating_ips[0].instance_id).to eql('1234')
         expect(floating_ips[0].pool).to eql('PublicNetwork-01')
@@ -663,4 +687,33 @@ describe VagrantPlugins::Openstack::NovaClient do
       end
     end
   end
+
+  describe 'attach_volume' do
+    context 'with token and project_id acquainted' do
+      context 'with volume id and device' do
+        it 'call the nova api' do
+          stub_request(:post, 'http://nova/a1b2c3/servers/9876/os-volume_attachments')
+          .with(headers:
+                  {
+                    'Accept' => 'application/json',
+                    'X-Auth-Token' => '123456'
+                  },
+                body: '{"volumeAttachment":{"volumeId":"n1n2","device":"/dev/vdg"}}')
+          .to_return(status: 200, body: '
+                  {
+                    "volumeAttachment": {
+                      "device": "/dev/vdg",
+                      "id": "attachment-01",
+                      "serverId": "9876",
+                      "volumeId": "n1n2"
+                    }
+                  }
+                ')
+
+          attachment = @nova_client.attach_volume(env, '9876', 'n1n2', '/dev/vdg')
+          expect(attachment['id']).to eq('attachment-01')
+        end
+      end
+    end
+  end
 end

data/spec/vagrant-openstack-provider/client/utils_spec.rb

@@ -128,7 +128,7 @@ describe VagrantPlugins::Openstack::HttpUtils do
     end
 
     context 'response code is 404' do
-      it 'should return raise a VagrantOpenstackError with conflict message' do
+      it 'should raise a VagrantOpenstackError with conflict message' do
         mock_resp = double.tap do |mock|
           mock.stub(:code).and_return(404)
           mock.stub(:headers)

data/spec/vagrant-openstack-provider/command/flavor_list_spec.rb

@@ -0,0 +1,44 @@
+require 'vagrant-openstack-provider/spec_helper'
+
+describe VagrantPlugins::Openstack::Command::FlavorList do
+  describe 'cmd' do
+
+    let(:nova) do
+      double('nova').tap do |nova|
+        nova.stub(:get_all_flavors) do
+          [
+            Flavor.new('001', 'small', '1', '1024', '10'),
+            Flavor.new('002', 'large', '4', '4096', '100')
+          ]
+        end
+      end
+    end
+
+    let(:env) do
+      Hash.new.tap do |env|
+        env[:ui] = double('ui')
+        env[:ui].stub(:info).with(anything)
+        env[:openstack_client] = double
+        env[:openstack_client].stub(:nova) { nova }
+      end
+    end
+
+    before :each do
+      @flavor_list_cmd = VagrantPlugins::Openstack::Command::FlavorList.new(nil, env)
+    end
+
+    it 'prints flovor list from server' do
+      nova.should_receive(:get_all_flavors).with(env)
+
+      expect(env[:ui]).to receive(:info).with('
++-----+-------+------+----------+----------------+
+| Id  | Name  | vCPU | RAM (Mo) | Disk size (Go) |
++-----+-------+------+----------+----------------+
+| 001 | small | 1    | 1024     | 10             |
+| 002 | large | 4    | 4096     | 100            |
++-----+-------+------+----------+----------------+')
+
+      @flavor_list_cmd.cmd('flavor-list', [], env)
+    end
+  end
+end

data/spec/vagrant-openstack-provider/command/floatingip_list_spec.rb

@@ -49,10 +49,27 @@ describe VagrantPlugins::Openstack::Command::FloatingIpList do
       @floating_ip_list_cmd = VagrantPlugins::Openstack::Command::FloatingIpList.new(nil, env)
     end
 
-    it 'should get floating ip and floating ip pool from server' do
+    it 'prints floating ip and floating ip pool from server' do
       nova.should_receive(:get_floating_ip_pools).with(env)
       nova.should_receive(:get_floating_ips).with(env)
-      @floating_ip_list_cmd.cmd('floatingip-list', ['--'], env)
+
+      expect(env[:ui]).to receive(:info).with('
++-------------------+
+| Floating IP pools |
++-------------------+
+| pool1             |
+| pool2             |
++-------------------+').ordered
+
+      expect(env[:ui]).to receive(:info).with('
++----+------------+-------+-------------+
+| Id | IP         | Pool  | Instance id |
++----+------------+-------+-------------+
+| 1  | 10.10.10.1 | pool1 |             |
+| 2  | 10.10.10.2 | pool2 | inst001     |
++----+------------+-------+-------------+').ordered
+
+      @floating_ip_list_cmd.cmd('floatingip-list', [], env)
     end
   end
 end

data/spec/vagrant-openstack-provider/command/image_list_spec.rb

@@ -0,0 +1,48 @@
+require 'vagrant-openstack-provider/spec_helper'
+
+describe VagrantPlugins::Openstack::Command::ImageList do
+  describe 'cmd' do
+
+    let(:nova) do
+      double('nova').tap do |nova|
+        nova.stub(:get_all_images) do
+          [
+            Item.new('0001', 'ubuntu'),
+            Item.new('0002', 'centos'),
+            Item.new('0003', 'debian')
+          ]
+        end
+      end
+    end
+
+    let(:env) do
+      Hash.new.tap do |env|
+        env[:ui] = double('ui')
+        env[:ui].stub(:info).with(anything)
+        env[:openstack_client] = double
+        env[:openstack_client].stub(:nova) { nova }
+      end
+    end
+
+    before :each do
+      @image_list_cmd = VagrantPlugins::Openstack::Command::ImageList.new(['--'], env)
+    end
+
+    it 'prints image list from server' do
+
+      allow(@image_list_cmd).to receive(:with_target_vms).and_return(nil)
+
+      nova.should_receive(:get_all_images).with(env)
+
+      expect(env[:ui]).to receive(:info).with('
++------+--------+
+| Id   | Name   |
++------+--------+
+| 0001 | ubuntu |
+| 0002 | centos |
+| 0003 | debian |
++------+--------+')
+      @image_list_cmd.cmd('image-list', [], env)
+    end
+  end
+end

data/spec/vagrant-openstack-provider/command/network_list_spec.rb

@@ -0,0 +1,67 @@
+require 'vagrant-openstack-provider/spec_helper'
+
+describe VagrantPlugins::Openstack::Command::NetworkList do
+  describe 'cmd' do
+
+    let(:neutron) do
+      double('neutron').tap do |neutron|
+        neutron.stub(:get_private_networks) do
+          [
+            Item.new('net-01', 'internal'),
+            Item.new('net-02', 'external')
+          ]
+        end
+        neutron.stub(:get_all_networks) do
+          [
+            Item.new('pub-01', 'public'),
+            Item.new('net-01', 'internal'),
+            Item.new('net-02', 'external')
+          ]
+        end
+      end
+    end
+
+    let(:env) do
+      Hash.new.tap do |env|
+        env[:ui] = double('ui')
+        env[:ui].stub(:info).with(anything)
+        env[:openstack_client] = double
+        env[:openstack_client].stub(:neutron) { neutron }
+      end
+    end
+
+    before :each do
+      @network_list_cmd = VagrantPlugins::Openstack::Command::NetworkList.new(nil, env)
+    end
+
+    it 'prints network list from server' do
+      neutron.should_receive(:get_private_networks).with(env)
+
+      expect(env[:ui]).to receive(:info).with('
++--------+----------+
+| Id     | Name     |
++--------+----------+
+| net-01 | internal |
+| net-02 | external |
++--------+----------+')
+
+      @network_list_cmd.cmd('network-list', [], env)
+    end
+
+    it 'prints all networks list from server' do
+      neutron.should_receive(:get_all_networks).with(env)
+
+      expect(env[:ui]).to receive(:info).with('
++--------+----------+
+| Id     | Name     |
++--------+----------+
+| pub-01 | public   |
+| net-01 | internal |
+| net-02 | external |
++--------+----------+')
+
+      @network_list_cmd.cmd('network-list', ['all'], env)
+    end
+
+  end
+end

data/spec/vagrant-openstack-provider/command/reset_spec.rb

@@ -0,0 +1,25 @@
+require 'vagrant-openstack-provider/spec_helper'
+
+describe VagrantPlugins::Openstack::Command::Reset do
+  describe 'cmd' do
+
+    let(:env) do
+      Hash.new.tap do |env|
+        env[:ui] = double('ui')
+        env[:ui].stub(:info).with(anything)
+        env[:machine] = double('machine')
+        env[:machine].stub(:data_dir) { '/my/data/dir' }
+      end
+    end
+
+    before :each do
+      @reset_cmd = VagrantPlugins::Openstack::Command::Reset.new(nil, env)
+    end
+
+    it 'resets vagrant openstack machines' do
+      expect(env[:ui]).to receive(:info).with('Vagrant OpenStack Provider has been reset')
+      expect(FileUtils).to receive(:remove_dir).with('/my/data/dir')
+      @reset_cmd.cmd('reset', [], env)
+    end
+  end
+end

data/spec/vagrant-openstack-provider/command/volume_list_spec.rb

@@ -1,6 +1,6 @@
 require 'vagrant-openstack-provider/spec_helper'
 
-describe VagrantPlugins::Openstack::Command::FloatingIpList do
+describe VagrantPlugins::Openstack::Command::VolumeList do
   describe 'cmd' do
 
     let(:cinder) do
@@ -25,8 +25,16 @@ describe VagrantPlugins::Openstack::Command::FloatingIpList do
       @volume_list_cmd = VagrantPlugins::Openstack::Command::VolumeList.new(nil, env)
     end
 
-    it 'should get volumes list from server' do
+    it 'prints volumes list from server' do
       cinder.should_receive(:get_all_volumes).with(env)
+      expect(env[:ui]).to receive(:info).with('
++-----+--------+-----------+-----------+-------------------------------------+
+| Id  | Name   | Size (Go) | Status    | Attachment (instance id and device) |
++-----+--------+-----------+-----------+-------------------------------------+
+| 987 | vol-01 | 2         | available |                                     |
+| 654 | vol-02 | 4         | in-use    | inst-01 (/dev/vdc)                  |
++-----+--------+-----------+-----------+-------------------------------------+')
+
       @volume_list_cmd.cmd('volume-list', [], env)
     end
   end

data/spec/vagrant-openstack-provider/config_resolver_spec.rb

@@ -0,0 +1,680 @@
+require 'vagrant-openstack-provider/spec_helper'
+
+describe VagrantPlugins::Openstack::ConfigResolver do
+
+  let(:config) do
+    double('config').tap do |config|
+      config.stub(:tenant_name) { 'testTenant' }
+      config.stub(:server_name) { 'testName' }
+      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 }
+    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(:neutron) do
+    double('neutron').tap do |neutron|
+      neutron.stub(:get_private_networks).with(anything) do
+        [Item.new('001', 'net-01'),
+         Item.new('002', 'net-02'),
+         Item.new('003', 'net-03'),
+         Item.new('004', 'net-04'),
+         Item.new('005', 'net-05'),
+         Item.new('006', 'net-06'),
+         Item.new('007', 'net-07-08'),
+         Item.new('008', 'net-07-08')]
+      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
+  end
+
+  let(:session) do
+    double('session').tap do |s|
+      s.stub(:endpoints) do
+        {
+          identity: 'http://keystone',
+          compute: 'http://nova',
+          volume: 'http://cinder',
+          network: 'http://neutron'
+        }
+      end
+    end
+  end
+
+  let(:env) do
+    Hash.new.tap do |env|
+      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].stub(:config) { machine_config }
+      env[:openstack_client] = double('openstack_client')
+      env[:openstack_client].stub(:neutron) { neutron }
+      env[:openstack_client].stub(:nova) { nova }
+      env[:openstack_client].stub(:cinder) { cinder }
+      env[:openstack_client].stub(:session) { session }
+    end
+  end
+
+  let(:ssh_config) do
+    double('ssh_config').tap do |config|
+      config.stub(:username) { nil }
+      config.stub(:port) { nil }
+    end
+  end
+
+  let(:machine_config) do
+    double('machine_config').tap do |config|
+      config.stub(:ssh) { ssh_config }
+    end
+  end
+
+  before :each do
+    ConfigResolver.send(:public, *ConfigResolver.private_instance_methods)
+    @action = ConfigResolver.new
+  end
+
+  describe 'resolve_ssh_username' do
+    context 'with machine.ssh.username' do
+      it 'returns machine.ssh.username' do
+        ssh_config.stub(:username) { 'machine ssh username' }
+        config.stub(:ssh_username) { nil }
+        expect(@action.resolve_ssh_username(env)).to eq('machine ssh username')
+      end
+    end
+    context 'with machine.ssh.username and config.ssh_username' do
+      it 'returns machine.ssh.username' do
+        ssh_config.stub(:username) { 'machine ssh username' }
+        config.stub(:ssh_username) { 'provider ssh username' }
+        expect(@action.resolve_ssh_username(env)).to eq('machine ssh username')
+      end
+    end
+    context 'with config.ssh_username' do
+      it 'returns config.ssh_username' do
+        ssh_config.stub(:username) { nil }
+        config.stub(:ssh_username) { 'provider ssh username' }
+        expect(@action.resolve_ssh_username(env)).to eq('provider ssh username')
+      end
+    end
+    context 'with no ssh username config' do
+      it 'fails' do
+        ssh_config.stub(:username) { nil }
+        config.stub(:ssh_username) { nil }
+        expect { @action.resolve_ssh_username(env) }.to raise_error(Errors::NoMatchingSshUsername)
+      end
+    end
+  end
+
+  describe 'resolve_flavor' do
+    context 'with id' do
+      it 'returns the specified flavor' do
+        config.stub(:flavor) { 'fl-001' }
+        nova.stub(:get_all_flavors).with(anything) do
+          [Flavor.new('fl-001', 'flavor-01', 2, 1024, 10),
+           Flavor.new('fl-002', 'flavor-02', 4, 2048, 50)]
+        end
+        @action.resolve_flavor(env).should eq(Flavor.new('fl-001', 'flavor-01', 2, 1024, 10))
+      end
+    end
+    context 'with name' do
+      it 'returns the specified flavor' do
+        config.stub(:flavor) { 'flavor-02' }
+        nova.stub(:get_all_flavors).with(anything) do
+          [Flavor.new('fl-001', 'flavor-01', 2, 1024, 10),
+           Flavor.new('fl-002', 'flavor-02', 4, 2048, 50)]
+        end
+        @action.resolve_flavor(env).should eq(Flavor.new('fl-002', 'flavor-02', 4, 2048, 50))
+      end
+    end
+    context 'with invalid identifier' do
+      it 'raise an error' do
+        config.stub(:flavor) { 'not-existing' }
+        nova.stub(:get_all_flavors).with(anything) do
+          [Flavor.new('fl-001', 'flavor-01', 2, 1024, 10),
+           Flavor.new('fl-002', 'flavor-02', 4, 2048, 50)]
+        end
+        expect { @action.resolve_flavor(env) }.to raise_error(Errors::NoMatchingFlavor)
+      end
+    end
+  end
+
+  describe 'resolve_image' do
+    context 'with id' do
+      it 'returns the specified flavor' do
+        config.stub(:image) { 'img-001' }
+        nova.stub(:get_all_images).with(anything) do
+          [Item.new('img-001', 'image-01'),
+           Item.new('img-002', 'image-02')]
+        end
+        @action.resolve_image(env).should eq(Item.new('img-001', 'image-01'))
+      end
+    end
+    context 'with name' do
+      it 'returns the specified flavor' do
+        config.stub(:image) { 'image-02' }
+        nova.stub(:get_all_images).with(anything) do
+          [Item.new('img-001', 'image-01'),
+           Item.new('img-002', 'image-02')]
+        end
+        @action.resolve_image(env).should eq(Item.new('img-002', 'image-02'))
+      end
+    end
+    context 'with invalid identifier' do
+      it 'raise an error' do
+        config.stub(:image) { 'not-existing' }
+        nova.stub(:get_all_images).with(anything) do
+          [Item.new('img-001', 'image-01'),
+           Item.new('img-002', 'image-02')]
+        end
+        expect { @action.resolve_image(env) }.to raise_error(Errors::NoMatchingImage)
+      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
+      it 'fails with an UnableToResolveFloatingIP error' do
+        config.stub(:floating_ip) { nil }
+        config.stub(:floating_ip_pool) { nil }
+        expect { @action.resolve_floating_ip(env) }.to raise_error(Errors::UnableToResolveFloatingIP)
+      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')
+      File.should_receive(:chmod).with(0600, '/data/dir/my-keypair-imported')
+      @action.generate_keypair(env).should eq('my-keypair-imported')
+    end
+  end
+
+  describe 'resolve_networks' do
+    context 'neutron service is available' do
+      context 'with network configured in all possible ways' do
+        it 'returns normalized network list' do
+
+          config.stub(:networks) do
+            ['001',
+             'net-02',
+             { id: '003', address: '1.2.3.4' },
+             { name: 'net-04', address: '5.6.7.8' },
+             { name: 'net-05' },
+             { id: '006' }]
+          end
+
+          expect(@action.resolve_networks(env)).to eq [{ uuid: '001' },
+                                                       { uuid: '002' },
+                                                       { uuid: '003', fixed_ip: '1.2.3.4' },
+                                                       { uuid: '004', fixed_ip: '5.6.7.8' },
+                                                       { uuid: '005' },
+                                                       { uuid: '006' }]
+        end
+      end
+
+      context 'with invalid network object' do
+        it 'raises an error' do
+          config.stub(:networks) { [1] }
+          expect { @action.resolve_networks(env) }.to raise_error(Errors::InvalidNetworkObject)
+        end
+      end
+
+      context 'with string that is neither an id nor name matching a network' do
+        it 'raises an error' do
+          config.stub(:networks) { ['not-exist'] }
+          expect { @action.resolve_networks(env) }.to raise_error(Errors::UnresolvedNetwork)
+        end
+      end
+
+      context 'with hash containing a bad id' do
+        it 'raises an error' do
+          config.stub(:networks) { [{ id: 'not-exist' }] }
+          expect { @action.resolve_networks(env) }.to raise_error(Errors::UnresolvedNetworkId)
+        end
+      end
+
+      context 'with hash containing a bad name' do
+        it 'raises an error' do
+          config.stub(:networks) { [{ name: 'not-exist' }] }
+          expect { @action.resolve_networks(env) }.to raise_error(Errors::UnresolvedNetworkName)
+        end
+      end
+
+      context 'with empty hash' do
+        it 'raises an error' do
+          config.stub(:networks) { [{}] }
+          expect { @action.resolve_networks(env) }.to raise_error(Errors::ConflictNetworkNameId)
+        end
+      end
+
+      context 'with hash containing both id and name' do
+        it 'raises an error' do
+          config.stub(:networks) { [{ id: '001', name: 'net-01' }] }
+          expect { @action.resolve_networks(env) }.to raise_error(Errors::ConflictNetworkNameId)
+        end
+      end
+
+      context 'with hash containing a name matching more than one network' do
+        it 'raises an error' do
+          config.stub(:networks) { [{ name: 'net-07-08' }] }
+          expect { @action.resolve_networks(env) }.to raise_error(Errors::MultipleNetworkName)
+        end
+      end
+    end
+
+    context 'neutron service is not available' do
+      context 'with network configured in all possible ways' do
+        it 'returns normalized network list' do
+          session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+          config.stub(:networks) do
+            ['001',
+             { id: '003', address: '1.2.3.4' },
+             { id: '006' }]
+          end
+
+          expect(@action.resolve_networks(env)).to eq [{ uuid: '001' },
+                                                       { uuid: '003', fixed_ip: '1.2.3.4' },
+                                                       { uuid: '006' }]
+        end
+      end
+
+      context 'with hash containing both id and name' do
+        it 'raises an error' do
+          session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+          config.stub(:networks) { [{ id: '001', name: 'net-01' }] }
+          expect { @action.resolve_networks(env) }.to raise_error(Errors::ConflictNetworkNameId)
+        end
+      end
+
+      context 'with hash containing name' do
+        it 'raises an error' do
+          session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+          config.stub(:networks) { [{ name: 'net-01' }] }
+          expect { @action.resolve_networks(env) }.to raise_error(Errors::NetworkServiceUnavailable)
+        end
+      end
+    end
+  end
+
+  describe 'resolve_volume_boot' do
+    context 'cinder service is available' 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)
+        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)
+        end
+      end
+    end
+
+    context 'cinder service is not available' do
+      context 'with string volume id' do
+        it 'returns normalized volume' do
+          session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+          config.stub(:volume_boot) { '001' }
+          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
+          session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+          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 'raise an error' do
+          session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+          config.stub(:volume_boot) { { name: 'vol-01' } }
+          expect { @action.resolve_volume_boot(env) }.to raise_error(Errors::VolumeServiceUnavailable)
+        end
+      end
+
+      context 'with hash volume id and device' do
+        it 'returns normalized volume' do
+          session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+          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 'raise an error' do
+          session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+          config.stub(:volume_boot) { { name: 'vol-01', device: 'vdb' } }
+          expect { @action.resolve_volume_boot(env) }.to raise_error(Errors::VolumeServiceUnavailable)
+        end
+      end
+
+      context 'with invalid volume object' do
+        it 'raises an error' do
+          session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+          config.stub(:volume_boot) { 1 }
+          expect { @action.resolve_volume_boot(env) }.to raise_error(Errors::InvalidVolumeObject)
+        end
+      end
+
+      context 'with hash containing both id and name' do
+        it 'raises an error' do
+          session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+          config.stub(:volume_boot) { { id: '001', name: 'vol-01' } }
+          expect { @action.resolve_volume_boot(env) }.to raise_error(Errors::ConflictVolumeNameId)
+        end
+      end
+    end
+  end
+
+  describe 'resolve_volumes' do
+    context 'cinder service is available' 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)
+        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)
+        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)
+        end
+      end
+    end
+
+    context 'cinder service is not available' do
+      context 'with volume attached in all possible ways' do
+        it 'returns normalized volume list' do
+          session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+          config.stub(:volumes) do
+            ['001',
+             { id: '003', device: '/dev/vdz' },
+             { id: '006' }]
+          end
+
+          expect(@action.resolve_volumes(env)).to eq [{ id: '001', device: nil },
+                                                      { id: '003', device: '/dev/vdz' },
+                                                      { id: '006', device: nil }]
+        end
+
+        context 'with hash containing both id and name' do
+          it 'raises an error' do
+            session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+            config.stub(:volumes) { [{ id: '001', name: 'vol-01' }] }
+            expect { @action.resolve_volumes(env) }.to raise_error(Errors::ConflictVolumeNameId)
+          end
+        end
+        context 'with hash containing name' do
+          it 'raises an error' do
+            session.stub(:endpoints) { { identity: 'http://keystone', compute: 'http://nova' } }
+            config.stub(:volumes) { [{ name: 'vol-01' }] }
+            expect { @action.resolve_volumes(env) }.to raise_error(Errors::VolumeServiceUnavailable)
+          end
+        end
+      end
+    end
+  end
+
+  describe 'resolve_security_groups' do
+    context 'with Hash and String objects' do
+      it 'returns normalized Hash list' do
+        config.stub(:security_groups) { ['group1', { name: 'group2' }] }
+        expect(@action.resolve_security_groups(env)).to eq([{ name: 'group1' }, { name: 'group2' }])
+      end
+    end
+  end
+end