vagrant-conoha 0.1.0

data/spec/vagrant-conoha/action/message_spec.rb

@@ -0,0 +1,33 @@
+require 'vagrant-conoha/spec_helper'
+
+describe VagrantPlugins::ConoHa::Action::Message do
+  let(:ui) do
+    double('ui').tap do |ui|
+      ui.stub(:info).with(anything)
+      ui.stub(:error).with(anything)
+    end
+  end
+
+  let(:env) do
+    {}.tap do |env|
+      env[:ui] = ui
+    end
+  end
+
+  let(:app) do
+    double('app').tap do |app|
+      app.stub(:call).with(anything)
+    end
+  end
+
+  describe 'call' do
+    context 'when message is given' do
+      it 'print out the message' do
+        expect(ui).to receive(:info).with('Message to show')
+        expect(app).to receive(:call)
+        @action = Message.new(app, nil, 'Message to show')
+        @action.call(env)
+      end
+    end
+  end
+end

data/spec/vagrant-conoha/action/provision_spec.rb

@@ -0,0 +1,104 @@
+require 'vagrant-conoha/spec_helper'
+
+#
+# Stubing all the interactions using the real
+# provisioner classes is somehow complicated...
+#
+class FakeProvisioner
+  def provision
+  end
+end
+
+class FakeShellProvisioner < FakeProvisioner
+  attr_accessor :config
+
+  def initialize(config)
+    @config = config
+  end
+end
+
+#
+# Monkeypatch the VagrantPlugins::Shell module
+# to enabled using an FakeShellProvisioner in
+# place of a the real shell provisioner class
+#
+module VagrantPlugins
+  module Shell
+    Provisioner = FakeShellProvisioner
+  end
+end
+
+describe VagrantPlugins::ConoHa::Action::ProvisionWrapper do
+  let(:app) do
+    double
+  end
+
+  let(:internal_provision_wrapper) do
+    double
+  end
+
+  before :each do
+    @action = ProvisionWrapper.new(app, nil)
+  end
+
+  describe 'execute' do
+    it 'call InternalProvisionWrapper and conitnue the middleware chain' do
+      expect(internal_provision_wrapper).to receive(:call)
+      InternalProvisionWrapper.stub(:new) { internal_provision_wrapper }
+      app.stub(:call) {}
+      @action.execute nil
+    end
+  end
+end
+
+describe VagrantPlugins::ConoHa::Action::InternalProvisionWrapper do
+  let(:env) do
+    {}
+  end
+
+  before :each do
+    @action = InternalProvisionWrapper.new(nil, env)
+  end
+
+  describe 'run_provisioner' do
+    context 'when running a shell provisioner' do
+      context 'without meta-arg' do
+        it 'does not change the provisioner config' do
+          env[:provisioner] = FakeShellProvisioner.new(OpenStruct.new.tap do |c|
+            c.args = %w(arg1 arg2)
+          end)
+
+          expect(env[:provisioner]).to receive(:provision)
+          expect(@action).to receive(:handle_shell_meta_args)
+
+          @action.run_provisioner(env)
+          expect(env[:provisioner].config.args).to eq(%w(arg1 arg2))
+        end
+      end
+
+      context 'with @@ssh_ip@@ meta-arg' do
+        it 'replace the meta-args in the provisioner config' do
+          env[:provisioner] = FakeShellProvisioner.new(OpenStruct.new.tap do |c|
+            c.args = ['arg1', '@@ssh_ip@@', 'arg3']
+          end)
+
+          VagrantPlugins::ConoHa::Action.stub(:get_ssh_info).and_return host: '192.168.0.1'
+          expect(env[:provisioner]).to receive(:provision)
+
+          @action.run_provisioner(env)
+          expect(env[:provisioner].config.args).to eq(%w(arg1 192.168.0.1 arg3))
+        end
+      end
+    end
+
+    context 'when running a provisioner other that the shell provisioner' do
+      it 'does not call handle_shell_meta_args' do
+        env[:provisioner] = FakeProvisioner.new
+        expect(@action).should_not_receive(:handle_shell_meta_args)
+        expect(env[:provisioner]).to receive(:provision)
+
+        @action.run_provisioner(env)
+      end
+    end
+  end
+end

data/spec/vagrant-conoha/action/read_ssh_info_spec.rb

@@ -0,0 +1,190 @@
+require 'vagrant-conoha/spec_helper'
+
+include VagrantPlugins::ConoHa::Action
+include VagrantPlugins::ConoHa::HttpUtils
+include VagrantPlugins::ConoHa::Domain
+
+describe VagrantPlugins::ConoHa::Action::ReadSSHInfo do
+  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(:ssh_username) { 'test_username' }
+      config.stub(:keypair_name) { nil }
+      config.stub(:public_key_path) { nil }
+      config.stub(:ssh_disabled) { false }
+    end
+  end
+
+  let(:nova) do
+    double('nova').tap do |nova|
+      nova.stub(:get_server_details).with(env, '1234') do
+        {
+          'addresses' => {
+            'net' => [
+              {
+                'addr' => '80.80.80.80',
+                'OS-EXT-IPS:type' => 'fixed',
+                'version' => 4
+              }
+            ]
+          }
+        }
+      end
+    end
+  end
+
+  let(:ssh_config) do
+    double('ssh_config').tap do |config|
+      config.stub(:username) { 'sshuser' }
+      config.stub(:port) { nil }
+    end
+  end
+
+  let(:machine_config) do
+    double('machine_config').tap do |config|
+      config.stub(:ssh) { ssh_config }
+    end
+  end
+
+  let(:env) do
+    {}.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(:config) { machine_config }
+      env[:machine].stub(:id) { '1234' }
+      env[:machine].stub(:data_dir) { '/data/dir' }
+      env[:openstack_client] = double('openstack_client')
+      env[:openstack_client].stub(:neutron) { neutron }
+      env[:openstack_client].stub(:nova) { nova }
+    end
+  end
+
+  let(:app) do
+    double('app').tap do |app|
+      app.stub(:call).with(anything)
+    end
+  end
+
+  before :each do
+    ReadSSHInfo.send(:public, *ReadSSHInfo.private_instance_methods)
+    @action = ReadSSHInfo.new(app, env)
+  end
+
+  describe 'call' do
+    context 'when called three times' do
+      it 'read ssh info only once' do
+        config.stub(:keypair_name) { 'my_keypair' }
+        @action.stub(:read_ssh_info) { { host: '', port: '', username: '' } }
+        expect(@action).to receive(:read_ssh_info).exactly(1).times
+        expect(app).to receive(:call)
+        (1..3).each { @action.call(env) }
+      end
+    end
+  end
+
+  describe 'read_ssh_info' do
+    context 'with deprecated ssh_username specified' do
+      context 'with ssh.username specified' do
+        it 'returns ssh.username' do
+          ssh_config.stub(:username) { 'sshuser' }
+          config.stub(:ssh_username) { 'test_username' }
+          config.stub(:floating_ip) { '80.80.80.80' }
+          config.stub(:keypair_name) { 'my_keypair' }
+          @action.read_ssh_info(env).should eq(host: '80.80.80.80', port: 22, username: 'sshuser', log_level: 'ERROR')
+        end
+      end
+      context 'without ssh.username specified' do
+        it 'returns ssh.username' do
+          ssh_config.stub(:username) { nil }
+          config.stub(:ssh_username) { 'test_username' }
+          config.stub(:floating_ip) { '80.80.80.80' }
+          config.stub(:keypair_name) { 'my_keypair' }
+          @action.read_ssh_info(env).should eq(host: '80.80.80.80', port: 22, username: 'test_username', log_level: 'ERROR')
+        end
+      end
+    end
+
+    context 'with ssh.port overriden' do
+      it 'returns ssh.port' do
+        ssh_config.stub(:port) { 33 }
+        config.stub(:floating_ip) { '80.80.80.80' }
+        config.stub(:keypair_name) { 'my_keypair' }
+        @action.read_ssh_info(env).should eq(host: '80.80.80.80', port: 33, username: 'sshuser', log_level: 'ERROR')
+      end
+    end
+
+    context 'with config.floating_ip specified' do
+      context 'with keypair_name specified' do
+        it 'returns the specified floating ip' do
+          config.stub(:floating_ip) { '80.80.80.80' }
+          config.stub(:keypair_name) { 'my_keypair' }
+          @action.read_ssh_info(env).should eq(host: '80.80.80.80', port: 22, username: 'sshuser', log_level: 'ERROR')
+        end
+      end
+
+      context 'with public_key_path specified' do
+        it 'returns the specified floating ip' do
+          config.stub(:floating_ip) { '80.80.80.80' }
+          config.stub(:keypair_name) { nil }
+          config.stub(:public_key_path) { '/public/key/path' }
+          @action.read_ssh_info(env).should eq(host: '80.80.80.80', port: 22, username: 'sshuser', log_level: 'ERROR')
+        end
+      end
+
+      context 'with neither keypair_name nor public_key_path specified' do
+        it 'returns the specified floating ip ' do
+          config.stub(:floating_ip) { '80.80.80.80' }
+          config.stub(:keypair_name) { nil }
+          config.stub(:public_key_path) { nil }
+          nova.stub(:get_server_details) do
+            {
+              'key_name' => 'my_keypair_name',
+              'addresses' => {
+                'net' => [
+                  {
+                    'addr' => '80.80.80.80',
+                    'OS-EXT-IPS:type' => 'floating'
+                  }
+                ]
+              }
+            }
+          end
+          expect(nova).to receive(:get_server_details).with(env, '1234')
+          @action.read_ssh_info(env).should eq(
+            host: '80.80.80.80',
+            port: 22,
+            username: 'sshuser',
+            private_key_path: '/data/dir/my_keypair_name',
+            log_level: 'ERROR')
+        end
+      end
+    end
+
+    context 'without config.floating_ip specified' do
+      it 'return the a floating_ip found by querying server details' do
+        nova.stub(:get_server_details).with(env, '1234') do
+          {
+            'addresses' => {
+              'toto' => [{
+                'addr' => '13.13.13.13'
+              }, {
+                'addr' => '12.12.12.12',
+                'OS-EXT-IPS:type' => 'fixed',
+                'version' => 4
+              }]
+            }
+          }
+        end
+        config.stub(:keypair_name) { 'my_keypair' }
+        @action.read_ssh_info(env).should eq(host: '12.12.12.12', port: 22, username: 'sshuser', log_level: 'ERROR')
+      end
+    end
+  end
+end

data/spec/vagrant-conoha/action/read_state_spec.rb

@@ -0,0 +1,81 @@
+require 'vagrant-conoha/spec_helper'
+
+describe VagrantPlugins::ConoHa::Action::ReadState do
+  let(:nova) do
+    double('nova')
+  end
+
+  let(:env) do
+    {}.tap do |env|
+      env[:ui] = double('ui').tap do |ui|
+        ui.stub(:info).with(anything)
+        ui.stub(:error).with(anything)
+      end
+      env[:openstack_client] = double('openstack_client').tap do |os|
+        os.stub(:nova) { nova }
+      end
+      env[:machine] = OpenStruct.new
+    end
+  end
+
+  let(:app) do
+    double('app').tap do |app|
+      app.stub(:call).with(anything)
+    end
+  end
+
+  describe 'call' do
+    context 'when server id is present' do
+      it 'set the state to the vm_state returned by nova' do
+        env[:machine].id = 'server_id'
+        nova.stub(:get_server_details).and_return('status' => 'ACTIVE')
+
+        expect(nova).to receive(:get_server_details).with(env, 'server_id')
+        expect(app).to receive(:call)
+
+        @action = ReadState.new(app, nil)
+        @action.call(env)
+
+        expect(env[:machine_state_id]).to eq(:active)
+      end
+      it 'set the state to the task_state returned by nova extension' do
+        env[:machine].id = 'server_id'
+        nova.stub(:get_server_details).and_return('OS-EXT-STS:task_state' => 'SUSPENDING')
+
+        expect(nova).to receive(:get_server_details).with(env, 'server_id')
+        expect(app).to receive(:call)
+
+        @action = ReadState.new(app, nil)
+        @action.call(env)
+
+        expect(env[:machine_state_id]).to eq(:suspending)
+      end
+    end
+    context 'when server id is not present' do
+      it 'set the state to :not_created' do
+        env[:machine].id = nil
+        expect(nova).to_not receive(:get_server_details)
+        expect(app).to receive(:call)
+
+        @action = ReadState.new(app, nil)
+        @action.call(env)
+
+        expect(env[:machine_state_id]).to eq(:not_created)
+      end
+    end
+    context 'when server cannot be found' do
+      it 'set the state to :not_created' do
+        env[:machine].id = 'server_id'
+        nova.stub(:get_server_details).and_return(nil)
+
+        expect(nova).to receive(:get_server_details).with(env, 'server_id')
+        expect(app).to receive(:call)
+
+        @action = ReadState.new(app, nil)
+        @action.call(env)
+
+        expect(env[:machine_state_id]).to eq(:not_created)
+      end
+    end
+  end
+end

data/spec/vagrant-conoha/action/resume_server_spec.rb

@@ -0,0 +1,49 @@
+require 'vagrant-conoha/spec_helper'
+
+describe VagrantPlugins::ConoHa::Action::Resume do
+  let(:nova) do
+    double('nova').tap do |nova|
+      nova.stub(:resume_server)
+    end
+  end
+
+  let(:env) do
+    {}.tap do |env|
+      env[:ui] = double('ui').tap do |ui|
+        ui.stub(:info).with(anything)
+        ui.stub(:error).with(anything)
+      end
+      env[:openstack_client] = double('openstack_client').tap do |os|
+        os.stub(:nova) { nova }
+      end
+      env[:machine] = OpenStruct.new
+    end
+  end
+
+  let(:app) do
+    double('app').tap do |app|
+      app.stub(:call).with(anything)
+    end
+  end
+
+  describe 'call' do
+    context 'when server id is present' do
+      it 'starts the server' do
+        env[:machine].id = 'server_id'
+        expect(nova).to receive(:resume_server).with(env, 'server_id')
+        expect(app).to receive(:call)
+        @action = Resume.new(app, nil)
+        @action.call(env)
+      end
+    end
+    context 'when server id is not present' do
+      it 'does nothing' do
+        env[:machine].id = nil
+        expect(nova).to_not receive(:resume_server)
+        expect(app).to receive(:call)
+        @action = Resume.new(app, nil)
+        @action.call(env)
+      end
+    end
+  end
+end