vagrant-proxmox 0.0.3 → 0.0.5

data/spec/actions/read_ssh_info_action_spec.rb

@@ -6,7 +6,7 @@ describe VagrantPlugins::Proxmox::Action::ReadSSHInfo do
 	let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
 	let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox)} }
 
-	subject { described_class.new(-> (_) {}, environment) }
+	subject(:action) { described_class.new(-> (_) {}, environment) }
 
 	describe '#call' do
 
@@ -14,16 +14,16 @@ describe VagrantPlugins::Proxmox::Action::ReadSSHInfo do
 
 		context 'when no ip address is configured' do
 			it 'should write no ssh info into env[:machine_ssh_info]' do
-				subject.call env
-				env[:machine_ssh_info].should == nil
+				action.call env
+				expect(env[:machine_ssh_info]).to eq(nil)
 			end
 		end
 
 		context 'when an ip address is configured' do
-			before { env[:machine].config.vm.stub(:networks) { [[:public_network, {ip: '127.0.0.1'}]] } }
+			before { allow(env[:machine].config.vm).to receive(:networks) { [[:public_network, {ip: '127.0.0.1'}]] } }
 			it 'should write the ssh info into env[:machine_ssh_info]' do
-				subject.call env
-				env[:machine_ssh_info].should == {host: '127.0.0.1', port: 22}
+				action.call env
+				expect(env[:machine_ssh_info]).to eq({host: '127.0.0.1', port: 22})
 			end
 		end
 

data/spec/actions/read_state_action_spec.rb

@@ -1,52 +1,54 @@
 require 'spec_helper'
 require 'actions/proxmox_action_shared'
 
-describe VagrantPlugins::Proxmox::Action::ReadState do
+module VagrantPlugins::Proxmox
 
-	let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
-	let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox)} }
+	describe VagrantPlugins::Proxmox::Action::ReadState do
 
-	subject { described_class.new(-> (_) {}, environment) }
+		let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
+		let(:connection) { Connection.new 'https://proxmox.example.com/api2/json' }
+		let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox), proxmox_connection: connection} }
+		let(:node) { 'localhost' }
+		let(:vm_id) { '100' }
+		let(:machine_id) { "#{node}/#{vm_id}" }
 
-	describe '#call' do
+		subject(:action) { described_class.new(-> (_) {}, environment) }
 
-		it_behaves_like 'a proxmox action call'
+		before do
+			allow(env[:machine]).to receive(:id) { machine_id }
+			allow(connection).to receive :get_vm_state
+		end
+
+		describe '#call' do
 
-		context 'when no machine id is defined' do
-			specify do
-				subject.call env
-				env[:machine_state_id].should == :not_created
+			it_behaves_like 'a proxmox action call'
+
+			it 'should store the machine state in env[:machine_state_id]' do
+				expect(connection).to receive(:get_vm_state).and_return :running
+				action.call env
+				expect(env[:machine_state_id]).to eq(:running)
 			end
-		end
 
-		context 'when the machine is not created' do
-			before { env[:machine].id = 'localhost/100' }
-			specify do
-				RestClient.should_receive(:get).with('https://your.proxmox.server/api2/json/nodes/localhost/openvz/100/status/current', anything).
-						and_raise(RestClient::InternalServerError)
-				subject.call env
-				env[:machine_state_id].should == :not_created
+			it 'should call get_vm_state with the node and vm_id' do
+				expect(connection).to receive(:get_vm_state).with vm_id
+				action.call env
 			end
-		end
 
-		context 'when the machine is stopped' do
-			before { env[:machine].id = 'localhost/100' }
-			specify do
-				RestClient.should_receive(:get).with('https://your.proxmox.server/api2/json/nodes/localhost/openvz/100/status/current', anything).
-						and_return({data: {status: 'stopped'}}.to_json)
-				subject.call env
-				env[:machine_state_id].should == :stopped
+			context 'when no machine id is defined' do
+				let(:machine_id) { nil }
+				it 'should [:machine_state_id] to :not_created' do
+					action.call env
+					expect(env[:machine_state_id]).to eq(:not_created)
+				end
 			end
-		end
 
-		context 'when the machine is running' do
-			before { env[:machine].id = 'localhost/100' }
-			specify do
-				RestClient.should_receive(:get).with('https://your.proxmox.server/api2/json/nodes/localhost/openvz/100/status/current', anything).
-						and_return({data: {status: 'running'}}.to_json)
-				subject.call env
-				env[:machine_state_id].should == :running
+			context 'when the server communication fails' do
+				before { allow(connection).to receive(:get_vm_state).and_raise ApiError::ConnectionError }
+				it 'should raise an error' do
+					expect { action.call env }.to raise_error Errors::CommunicationError
+				end
 			end
+
 		end
 
 	end

data/spec/actions/select_node_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'actions/proxmox_action_shared'
+
+module VagrantPlugins::Proxmox
+
+	describe VagrantPlugins::Proxmox::Action::SelectNode do
+
+		let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
+		let(:connection) { Connection.new 'https://proxmox.example.com/api2/json' }
+		let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox),
+								 proxmox_connection: connection, proxmox_nodes: nodes} }
+		let(:nodes) { ['node1', 'node2'] }
+
+		subject(:action) { described_class.new(-> (_) {}, environment) }
+
+		describe '#call' do
+
+			before do
+				allow(nodes).to receive(:sample).and_return 'node2'
+			end
+
+			it_behaves_like 'a proxmox action call'
+
+			it 'randomly selects a node from the list of available nodes' do
+				action.call env
+				expect(env[:proxmox_selected_node]).to eq('node2')
+			end
+
+		end
+
+	end
+
+end

data/spec/actions/shutdown_vm_action_spec.rb

@@ -1,35 +1,63 @@
 require 'spec_helper'
 require 'actions/proxmox_action_shared'
 
-describe VagrantPlugins::Proxmox::Action::ShutdownVm do
+module VagrantPlugins::Proxmox
 
-	let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
-	let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox),
-							 proxmox_nodes: [{node: 'localhost'}],
-							 ui: double('ui').as_null_object} }
+	describe Action::ShutdownVm do
 
-	subject { described_class.new(-> (_) {}, environment) }
+		let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
+		let(:connection) { Connection.new 'https://proxmox.example.com/api2/json' }
+		let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox),
+								 ui: double('ui').as_null_object,
+								 proxmox_connection: connection} }
 
-	describe '#call' do
+		subject(:action) { described_class.new(-> (_) {}, environment) }
 
-		before do
-			env[:machine].id = 'localhost/100'
-			allow(RestClient).to receive(:post).and_return({data: 'task_id'}.to_json)
-			allow(RestClient).to receive(:get).and_return({data: {exitstatus: 'OK'}}.to_json)
-		end
+		describe '#call' do
 
-		it_behaves_like 'a proxmox action call'
-		it_behaves_like 'a blocking proxmox action'
+			before do
+				env[:machine].id = 'localhost/100'
+				allow(connection).to receive_messages :shutdown_vm => 'OK'
+			end
 
-		it 'should send a post request that shuts down the openvz container' do
-			RestClient.should_receive(:post).with('https://your.proxmox.server/api2/json/nodes/localhost/openvz/100/status/shutdown', nil, anything)
-			subject.call env
-		end
+			it_behaves_like 'a proxmox action call'
+
+			it 'should call the shutdown_vm function of connection' do
+				expect(connection).to receive(:shutdown_vm).with '100'
+				action.call env
+			end
+
+			it 'should print a message to the user interface' do
+				expect(env[:ui]).to receive(:info).with 'Shutting down the virtual machine...'
+				expect(env[:ui]).to receive(:info).with 'Done!'
+				action.call env
+			end
+
+			context 'when the proxmox server responds with an error to the shutdown request' do
+
+				context 'when the proxmox server replies with an internal server error to the shutdown request' do
+					it 'should raise a VMShutdownError' do
+						allow(connection).to receive(:shutdown_vm).and_raise ApiError::ServerError
+						expect { action.send :call, env }.to raise_error Errors::VMShutdownError
+					end
+				end
+
+				context 'when the proxmox server replies with an internal server error to the task status request' do
+					it 'should raise a VMShutdownError' do
+						allow(connection).to receive(:shutdown_vm).and_raise ApiError::ServerError
+						expect { action.send :call, env }.to raise_error Errors::VMShutdownError
+					end
+				end
+
+				context 'when the proxmox server does not reply the task status request with OK' do
+					it 'should raise a VMShutdownError' do
+						allow(connection).to receive_messages :shutdown_vm => 'shutdown vm error'
+						expect { action.send :call, env }.to raise_error Errors::VMShutdownError, /shutdown vm error/
+					end
+				end
+
+			end
 
-		it 'should print a message to the user interface' do
-			env[:ui].should_receive(:info).with 'Shutting down the virtual machine...'
-			env[:ui].should_receive(:info).with 'Done!'
-			subject.call env
 		end
 
 	end

data/spec/actions/start_vm_action_spec.rb

@@ -1,47 +1,101 @@
 require 'spec_helper'
 require 'actions/proxmox_action_shared'
 
-describe VagrantPlugins::Proxmox::Action::StartVm do
+module VagrantPlugins::Proxmox
 
-	let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
-	let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox),
-							 proxmox_nodes: [{node: 'localhost'}],
-							 ui: double('ui').as_null_object} }
+	describe Action::StartVm do
 
-	subject { described_class.new(-> (_) {}, environment) }
+		let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
+		let(:connection) { Connection.new 'https://proxmox.example.com/api2/json' }
+		let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox),
+								 ui: double('ui').as_null_object,
+								 proxmox_connection: connection} }
+		let(:ssh_reachable) { true }
+		let(:ssh_timeout) { 60 }
+		let(:ssh_status_check_interval) { 5 }
 
-	describe '#call' do
+		subject(:action) { described_class.new(-> (_) {}, environment) }
 
-		before do
-			env[:machine].id = 'localhost/100'
-			allow(RestClient).to receive(:post).and_return({data: 'task_id'}.to_json)
-			allow(RestClient).to receive(:get).and_return({data: {exitstatus: 'OK'}}.to_json)
-			allow(env[:machine].communicate).to receive(:ready?).and_return true
-		end
+		describe '#call' do
 
-		it_behaves_like 'a proxmox action call'
-		it_behaves_like 'a blocking proxmox action'
+			before do
+				env[:machine].id = 'localhost/100'
+				allow(connection).to receive_messages :start_vm => 'OK'
+				allow(env[:machine].communicate).to receive_messages :ready? => ssh_reachable
+			end
 
-		it 'should send a post request that starts the openvz container' do
-			RestClient.should_receive(:post).with('https://your.proxmox.server/api2/json/nodes/localhost/openvz/100/status/start', nil, anything)
-			subject.call env
-		end
+			it_behaves_like 'a proxmox action call'
 
-		it 'should print a message to the user interface' do
-			env[:ui].should_receive(:info).with 'Starting the virtual machine...'
-			env[:ui].should_receive(:info).with 'Done!'
-			env[:ui].should_receive(:info).with 'Waiting for SSH connection...'
-			env[:ui].should_receive(:info).with 'Done!'
-			subject.call env
-		end
+			it 'should call the start_vm function of connection' do
+				expect(connection).to receive(:start_vm).with '100'
+				action.call env
+			end
 
-		it 'should periodically call env[:machine].communicate.ready? to check for ssh access' do
-			expect(env[:machine].communicate).to receive(:ready?).and_return false
-			expect(subject).to receive(:sleep).with 1
-			expect(env[:machine].communicate).to receive(:ready?).and_return true
-			subject.call env
-		end
+			it 'should print a message to the user interface' do
+				expect(env[:ui]).to receive(:info).with 'Starting the virtual machine...'
+				expect(env[:ui]).to receive(:info).with 'Done!'
+				expect(env[:ui]).to receive(:info).with 'Waiting for SSH connection...'
+				expect(env[:ui]).to receive(:info).with 'Done!'
+				action.call env
+			end
 
-	end
+			it 'should periodically call env[:machine].communicate.ready? to check for ssh access' do
+				expect(env[:machine].communicate).to receive(:ready?).and_return false
+				expect(subject).to receive(:sleep).with ssh_status_check_interval
+				expect(env[:machine].communicate).to receive(:ready?).and_return true
+				action.call env
+			end
+
+			context 'when the proxmox server responds with an error to the start request' do
+
+				context 'when the proxmox server replies with an internal server error to the start request' do
+					it 'should raise a VMStartError' do
+						allow(connection).to receive(:start_vm).and_raise ApiError::ServerError
+						expect { action.send :call, env }.to raise_error Errors::VMStartError
+					end
+				end
+
+				context 'when the proxmox server replies with an internal server error to the task status request' do
+					it 'should raise a VMStartError' do
+						allow(connection).to receive(:start_vm).and_raise ApiError::ServerError
+						expect { action.send :call, env }.to raise_error Errors::VMStartError
+					end
+				end
+
+				context 'when the proxmox server does not reply the task status request with OK' do
+					it 'should raise a VMStartError' do
+						allow(connection).to receive_messages :start_vm => 'start vm error'
+						expect { action.send :call, env }.to raise_error Errors::VMStartError, /start vm error/
+					end
+				end
 
+			end
+
+			context 'when no ssh connection can be established after startup' do
+
+				let(:ssh_reachable) { false }
+
+				before do
+					allow(action).to receive(:sleep) { |duration| Timecop.travel(Time.now + duration) }
+					Timecop.freeze
+				end
+
+				after do
+					Timecop.return
+				end
+
+				it 'should wait the default timeout' do
+					begin
+						action.call env
+					rescue Errors::SSHError
+					end
+					expect(Time).to have_elapsed ssh_timeout.seconds
+				end
+
+				it 'should raise an ssh error' do
+					expect { action.send :call, env }.to raise_error Errors::SSHError, /Unable to establish an ssh connection/
+				end
+			end
+		end
+	end
 end

data/spec/actions/stop_vm_action_spec.rb

@@ -1,37 +1,64 @@
 require 'spec_helper'
 require 'actions/proxmox_action_shared'
 
-describe VagrantPlugins::Proxmox::Action::StopVm do
+module VagrantPlugins::Proxmox
 
-	let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
-	let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox),
-							 proxmox_nodes: [{node: 'localhost'}],
-							 ui: double('ui').as_null_object} }
+	describe Action::StopVm do
 
-	subject { described_class.new(-> (_) {}, environment) }
+		let(:environment) { Vagrant::Environment.new vagrantfile_name: 'dummy_box/Vagrantfile' }
+		let(:connection) { Connection.new 'https://proxmox.example.com/api2/json' }
+		let(:env) { {machine: environment.machine(environment.primary_machine_name, :proxmox),
+								 ui: double('ui').as_null_object, proxmox_connection: connection} }
 
-	describe '#call' do
+		subject(:action) { described_class.new(-> (_) {}, environment) }
 
-		before do
-			env[:machine].id = 'localhost/100'
-			allow(RestClient).to receive(:post).and_return({data: 'task_id'}.to_json)
-			allow(RestClient).to receive(:get).and_return({data: {exitstatus: 'OK'}}.to_json)
-		end
+		describe '#call' do
 
-		it_behaves_like 'a proxmox action call'
-		it_behaves_like 'a blocking proxmox action'
+			before do
+				env[:machine].id = 'localhost/100'
+				allow(connection).to receive_messages :stop_vm => 'OK'
+			end
 
-		it 'should send a post request that stops the openvz container' do
-			RestClient.should_receive(:post).with('https://your.proxmox.server/api2/json/nodes/localhost/openvz/100/status/stop', nil, anything)
-			subject.call env
-		end
+			it_behaves_like 'a proxmox action call'
+
+			it 'should call the stop_vm function of connection' do
+				expect(connection).to receive(:stop_vm).with '100'
+				action.call env
+			end
+
+			it 'should print a message to the user interface' do
+				expect(env[:ui]).to receive(:info).with 'Stopping the virtual machine...'
+				expect(env[:ui]).to receive(:info).with 'Done!'
+				action.call env
+			end
+
+			context 'when the proxmox server responds with an error to the stop request' do
+
+				context 'when the proxmox server replies with an internal server error to the stop request' do
+					it 'should raise a VMStopError' do
+						allow(connection).to receive(:stop_vm).and_raise ApiError::ServerError
+						expect { action.send :call, env }.to raise_error Errors::VMStopError
+					end
+				end
+
+				context 'when the proxmox server replies with an internal server error to the task status request' do
+					it 'should raise a VMStopError' do
+						allow(connection).to receive(:stop_vm).and_raise ApiError::ServerError
+						expect { action.send :call, env }.to raise_error Errors::VMStopError
+					end
+				end
+
+				context 'when the proxmox server does not reply the task status request with OK' do
+					it 'should raise a VMStopError' do
+						allow(connection).to receive_messages :stop_vm => 'stop vm error'
+						expect { action.send :call, env }.to raise_error Errors::VMStopError, /stop vm error/
+					end
+				end
+
+			end
 
-		it 'should print a message to the user interface' do
-			env[:ui].should_receive(:info).with 'Stopping the virtual machine...'
-			env[:ui].should_receive(:info).with 'Done!'
-			subject.call env
 		end
 
 	end
 
-end
+end