nodespec 0.1.9 → 0.1.10

data/spec/backend_proxy/winrm_spec.rb

@@ -0,0 +1,34 @@
+require 'nodespec/backend_proxy/winrm'
+
+module NodeSpec
+  module BackendProxy
+    describe WinRM do
+      let(:winrm) { double('winrm session') }
+      let(:subject) {WinRM.new(winrm)}
+      before do
+        allow(winrm).to receive(:set_timeout).with(NodeSpec::RunOptions.command_timeout)
+      end
+
+      it 'returns true upon successful execution' do
+        result = {exitcode: 0, data: [{stdout: 'output line 1'}, {stdout: 'output line 2'}]}
+        allow(winrm).to receive(:powershell).and_return(result)
+
+        expect(subject.execute('command')).to be_truthy
+      end
+
+      it 'returns false if stderr not empty' do
+        result = {exitcode: 0, data: [{stdout: 'output line 1', stderr: 'error line 1'}, {stdout: 'output line 2', stderr: 'error line 2'}]}
+        allow(winrm).to receive(:powershell).and_return(result)
+
+        expect(subject.execute('command')).to be_falsy
+      end
+
+      it 'returns false if exitcode not zero' do
+        result = {exitcode: 1, data: [{stdout: 'output line 1'}, {stdout: 'output line 2'}]}
+        allow(winrm).to receive(:powershell).and_return(result)
+
+        expect(subject.execute('command')).to be_falsy
+      end
+    end
+  end
+end

data/spec/command_execution_spec.rb

@@ -0,0 +1,36 @@
+require 'nodespec/command_execution'
+
+module NodeSpec
+  describe CommandExecution do
+    let(:subject) {Object.new.extend CommandExecution}
+    
+    it 'does not raise an error if the command succeeds' do
+      subject.execute_within_timeout('test command') { true }
+    end
+
+    it 'raises an error if the command fails' do
+      expect {
+        subject.execute_within_timeout('test command') { false }
+      }.to raise_error CommandExecution::CommandExecutionError
+    end
+
+    context 'custom timeout' do
+      it 'fails if running longer than the set timeout' do
+        expect {
+          subject.execute_within_timeout('test command', 1) { sleep(2) }
+        }.to raise_error Timeout::Error
+      end
+    end
+
+    context 'preset timeout' do
+      before do
+        NodeSpec::RunOptions.command_timeout = 1
+      end
+      it 'fails if running longer than the set timeout' do
+        expect {
+          subject.execute_within_timeout('test command') { sleep(2) }
+        }.to raise_error Timeout::Error
+      end
+    end
+  end
+end

data/spec/communication_adapters/aws_ec2_spec.rb

@@ -0,0 +1,70 @@
+require 'aws-sdk'
+require 'spec_helper'
+require 'nodespec/communication_adapters/aws_ec2'
+
+module NodeSpec
+  module CommunicationAdapters
+    describe AwsEc2 do
+      let(:ec2_instance) {double('ec2 instance')}
+
+      before do
+        instance_collection = double
+        allow(AWS).to receive_message_chain(:ec2, :instances).and_return(instance_collection)
+        allow(instance_collection).to receive(:[]).with('test-instance').and_return(ec2_instance)
+      end
+
+      describe 'connecting to a running instance' do
+        before do
+          allow(ec2_instance).to receive(:exists?).ordered.and_return(true)
+          allow(ec2_instance).to receive(:status).ordered.and_return(:running)
+          allow(ec2_instance).to receive(:public_dns_name).ordered.and_return('test hostname')
+        end
+
+        %w[ssh winrm].each do |connection|
+          describe "#{connection} communicator" do
+            include_context "new_#{connection}_communicator", 'test hostname', 'test_os', 'foo' => 'bar'
+
+            it 'returns communicator with the instance name from the node name' do
+              expect(AwsEc2.communicator_for('test-instance', 'test_os', connection => {'foo' => 'bar'})).to eq("#{connection} communicator")
+            end
+
+            it 'returns communicator with the instance name from the options' do
+              expect(AwsEc2.communicator_for('test_node', 'test_os', 'instance' => 'test-instance', connection => {'foo' => 'bar'})).to eq("#{connection} communicator")
+            end
+          end
+        end
+
+        describe 'openssh default connection' do
+          include_context "new_ssh_communicator", 'test hostname', 'test_os', {}
+
+          it 'returns an ssh communicator' do
+            expect(AwsEc2.communicator_for('test-instance', 'test_os')).to eq("ssh communicator")
+          end
+        end
+      end
+
+      describe 'connecting to an unreachable instance' do
+        context 'not existing instance' do
+          before do
+            allow(ec2_instance).to receive(:exists?).ordered.and_return(false)
+          end
+
+          it 'raises an error' do
+            expect {AwsEc2.communicator_for('test-instance', 'test_os', 'foo' => 'bar')}.to raise_error
+          end
+        end
+
+        context 'not running instance' do
+          before do
+            allow(ec2_instance).to receive(:exists?).ordered.and_return(true)
+            allow(ec2_instance).to receive(:status).ordered.and_return(:whatever_else)
+          end
+
+          it 'raises an error' do
+            expect {AwsEc2.communicator_for('test-instance', 'test_os', 'foo' => 'bar')}.to raise_error
+          end
+        end
+      end
+    end
+  end
+end

data/spec/communication_adapters/local_backend_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'nodespec/communication_adapters/local_backend'
+
+module NodeSpec
+  module CommunicationAdapters
+    describe LocalBackend do
+      let(:subject) {Object.new.extend LocalBackend}
+
+      context 'no os' do
+        before do
+          def subject.os
+          end
+        end
+        it_behaves_like 'providing a backend', 'Exec'
+      end
+      
+      context 'UN*X os' do
+        before do
+          def subject.os
+            'CentOS'
+          end
+        end
+
+        it_behaves_like 'providing a backend', 'Exec'
+      end
+
+      context 'Windows os' do
+        before do
+          def subject.os
+            'Windows'
+          end
+        end
+
+        it_behaves_like 'providing a backend', 'Cmd'
+      end
+    end
+  end
+end

data/spec/communication_adapters/native_communicator_spec.rb

@@ -0,0 +1,53 @@
+require 'nodespec/communication_adapters/native_communicator'
+
+module NodeSpec
+  module CommunicationAdapters
+    describe NativeCommunicator do
+      it 'provides a local backend' do
+        expect(NativeCommunicator.new).to be_a(LocalBackend)
+      end
+
+      describe '#initialize' do
+        [nil, 'Test OS'].each do |os|
+          it 'holds the os information' do
+            expect(NativeCommunicator.new(os).os).to eq os
+          end
+        end
+      end
+
+      describe '#bind_to' do
+        let(:rspec_configuration) {double('rspec configuration')}
+
+        context('ssh session') do
+          let(:ssh_session) {double('ssh session')}
+
+          before do
+            allow(rspec_configuration).to receive(:ssh).and_return(ssh_session)
+            allow(rspec_configuration).to receive(:winrm)
+            [:close, :host].each {|m| allow(ssh_session).to receive(m)}
+            allow(ssh_session).to receive(:options).and_return({port: 'port'})
+            expect(rspec_configuration).to receive(:ssh=).with(nil)
+          end
+
+          it 'closes and removes an existing ssh session' do
+            subject.bind_to(rspec_configuration)
+          end
+        end
+
+        context('winrm session') do
+          let(:winrm_session) {double('winrm session')}
+
+          before do
+            allow(rspec_configuration).to receive(:ssh)
+            allow(rspec_configuration).to receive(:winrm).and_return(winrm_session)
+            expect(rspec_configuration).to receive(:winrm=).with(nil)
+          end
+
+          it 'removes an existing winrm session' do
+            subject.bind_to(rspec_configuration)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/communication_adapters/remote_backend_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'nodespec/communication_adapters/remote_backend'
+
+module NodeSpec
+  module CommunicationAdapters
+    describe RemoteBackend do
+      let(:subject) {
+        Object.new.tap do |obj|
+          obj.extend RemoteBackend
+          def obj.session
+            'session'
+          end
+        end
+      }
+
+      context 'no os' do
+        before do
+          def subject.os
+          end
+        end
+
+        it_behaves_like 'providing a backend', 'Ssh'
+      end
+
+      context 'UN*X os' do
+        before do
+          def subject.os
+            'CentOS'
+          end
+        end
+
+        it_behaves_like 'providing a backend', 'Ssh'
+      end
+
+      context 'Windows os' do
+        before do
+          def subject.os
+            'Windows'
+          end
+        end
+
+        it_behaves_like 'providing a backend', 'WinRM'
+      end
+    end
+  end
+end

data/spec/communication_adapters/ssh_communicator_spec.rb

@@ -0,0 +1,121 @@
+require 'nodespec/communication_adapters/ssh_communicator'
+
+module NodeSpec
+  module CommunicationAdapters
+    describe SshCommunicator do
+      let(:rspec_configuration) {double('rspec configuration')}
+      let(:ssh_session) {double('ssh session')}
+
+      before do
+        allow(Net::SSH).to receive(:start).with('test.host.name', 'testuser', port: 1234, password: 'testpassword', keys: 'testkeys').and_return('new session')
+      end
+
+      shared_context 'existing session' do |hostname, port|
+        before do
+          allow(rspec_configuration).to receive(:ssh).and_return(ssh_session)
+          allow(ssh_session).to receive(:host).and_return(hostname)
+          allow(ssh_session).to receive(:options).and_return({port: port})
+        end
+      end
+
+      shared_examples 'creating new session' do
+        before do
+          expect(rspec_configuration).to receive(:ssh=).with('new session')
+          expect(rspec_configuration).to receive(:host=).with('test.host.name')
+        end
+
+        it 'creates and holds a new session' do
+          subject.bind_to(rspec_configuration)
+
+          expect(subject.session).to eq('new session')
+        end
+      end
+
+      shared_examples 'binding to configuration' do
+        before do
+          allow(rspec_configuration).to receive(:winrm)
+        end
+
+        context 'existing winrm session' do
+          before do
+            allow(rspec_configuration).to receive(:winrm).and_return('winrm')
+            allow(rspec_configuration).to receive(:ssh).and_return(nil)
+            expect(rspec_configuration).to receive(:winrm=).with(nil)
+          end
+
+          include_examples 'creating new session'
+        end
+
+        context 'no existing ssh session' do
+          before do
+            allow(rspec_configuration).to receive(:ssh).and_return(nil)
+          end
+
+          include_examples 'creating new session'
+        end
+
+        {'another host' => 1234, 'test.host.name' => 5678}.each do |hostname, port|
+          context 'existing session with different connection' do
+            include_context 'existing session', hostname, port
+            before do
+              expect(ssh_session).to receive(:close)
+              allow(ssh_session).to receive(:closed?).and_return(true)
+            end
+            include_examples 'creating new session'
+          end
+        end
+
+        context 'existing ssh session with same connection' do
+          include_context 'existing session', 'test.host.name', 1234          
+          context 'open session' do
+            before { allow(ssh_session).to receive(:closed?).and_return(false) }
+
+            it 'does not change the current rspec configuration' do
+              expect(Net::SSH).not_to receive(:start)
+              expect(rspec_configuration).not_to receive(:ssh=)
+              expect(rspec_configuration).not_to receive(:host=)
+        
+              subject.bind_to(rspec_configuration)
+
+              expect(subject.session).to eq(ssh_session)
+            end
+          end
+
+          context 'closed session' do
+            before { allow(ssh_session).to receive(:closed?).and_return(true) }
+            include_examples 'creating new session'
+          end
+        end
+      end
+
+      context 'with given credentials' do
+        let(:subject) {SshCommunicator.new('test.host.name', nil, 'port' => 1234, 'user' => 'testuser', 'password' => 'testpassword', 'keys' => 'testkeys')}
+        before do
+          allow(Net::SSH).to receive(:configuration_for).and_return({})
+        end
+        include_examples 'binding to configuration'
+      end
+
+      context 'credentials from OpenSSH config files' do
+        let(:subject) {SshCommunicator.new('test.host.name', nil, 'port' => 1234, 'user' => 'testuser')}
+        before do
+          allow(Net::SSH).to receive(:configuration_for).with('test.host.name').and_return(password: 'testpassword', keys: 'testkeys')
+        end
+
+        include_examples 'binding to configuration'
+      end
+
+      it 'provides a remote backend' do
+        expect(SshCommunicator.new('test.host.name')).to be_a(RemoteBackend)
+      end
+
+      describe '#initialize' do
+        [nil, 'Test OS'].each do |os|
+          it 'holds the os information' do
+            expect(SshCommunicator.new('test.host.name', os, {}).os).to eq os
+          end
+        end
+      end
+    end
+  end
+end

data/spec/communication_adapters/ssh_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'nodespec/communication_adapters/ssh'
+
+module NodeSpec
+  module CommunicationAdapters
+    describe Ssh do
+      include_context 'new_ssh_communicator', 'test.host.name', 'test_os', {'foo' => 'bar'}
+
+      it 'returns communicator with the host name from the node name' do
+        expect(Ssh.communicator_for('test.host.name', 'test_os', 'foo' => 'bar')).to eq('ssh communicator')
+      end
+
+      it 'returns communicator with the host name from the options' do
+        expect(Ssh.communicator_for('test_node', 'test_os', 'host' => 'test.host.name', 'foo' => 'bar')).to eq('ssh communicator')
+      end
+    end
+  end
+end

data/spec/communication_adapters/vagrant_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'nodespec/communication_adapters/vagrant'
+
+module NodeSpec
+  module CommunicationAdapters
+    describe Vagrant do
+      [['test_vm', 'test_os'], ['test_node', 'test_os', {'vm_name' => 'test_vm'}]].each do |args|
+        describe "#communicator_for" do
+          let(:cmd_status) { double('status') }
+
+          before(:each) do
+            expect(Open3).to receive(:capture2e).with('vagrant --machine-readable ssh-config test_vm').and_return([cmd_output, cmd_status])
+          end
+
+          context 'vm not running' do
+            let(:cmd_output) {
+              '1402310908,,error-exit,Vagrant::Errors::SSHNotReady,The provider...'
+            }
+
+            it 'raises an error' do
+              allow(cmd_status).to receive(:success?).and_return(false)
+
+              expect {Vagrant.communicator_for(*args)}.to raise_error 'Vagrant::Errors::SSHNotReady,The provider...'
+            end
+          end
+
+          context 'vm running' do
+            let(:cmd_output) {
+              <<-EOS
+Host test_vm
+  HostName test.host.name
+  User testuser
+  Port 1234
+  UserKnownHostsFile /dev/null
+  StrictHostKeyChecking no
+  PasswordAuthentication no
+  IdentityFile /test/path/private_key
+  IdentitiesOnly yes
+  LogLevel FATAL
+EOS
+            }
+
+            include_context 'new_ssh_communicator', 'test.host.name', 'test_os', {
+              'user' => 'testuser',
+              'port' => 1234,
+              'keys' => '/test/path/private_key'
+            } do
+              before do
+                allow(cmd_status).to receive(:success?).and_return(true)
+              end
+
+              it 'returns and ssh communicator initialized from the vagrant command output' do
+                expect(Vagrant.communicator_for(*args)).to eq('ssh communicator')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/communication_adapters/winrm_communicator_spec.rb

@@ -0,0 +1,111 @@
+require 'winrm'
+require 'nodespec/communication_adapters/winrm_communicator'
+
+module NodeSpec
+  module CommunicationAdapters
+    describe WinrmCommunicator do
+      let(:rspec_configuration) {double('rspec configuration')}
+      shared_examples 'creating new session' do |hostname, port, transport, options|
+        before do
+          allow(WinRM::WinRMWebService).to receive(:new).with("http://#{hostname}:#{port}/wsman", transport, options).and_return('new session')
+          expect(rspec_configuration).to receive(:winrm=).with('new session')
+          expect(rspec_configuration).to receive(:host=).with(hostname)
+        end
+
+        it 'creates and holds a new session' do
+          subject.bind_to(rspec_configuration)
+
+          expect(subject.session).to eq('new session')
+        end
+      end
+
+      describe 'connecting to the web service' do
+        before do
+          allow(rspec_configuration).to receive(:ssh)
+          allow(rspec_configuration).to receive(:winrm).and_return(nil)
+        end
+
+        context 'default port and transport' do
+          let(:subject) {WinrmCommunicator.new('test.host.name', nil, 'foo' => 'bar')}
+          include_examples 'creating new session', 'test.host.name', 5985, :plaintext, {foo: 'bar', disable_sspi: true}
+        end
+
+        context 'custom port and transport' do
+          let(:subject) {WinrmCommunicator.new('test.host.name', nil, 'port' => 1234, 'transport' => 'test_transport', 'foo' => 'bar')}
+          include_examples 'creating new session', 'test.host.name', 1234, :test_transport, {foo: 'bar'}
+        end
+      end
+
+      describe 'binding to configuration' do
+        let(:winrm_session) {double('winrm session')}
+        let(:subject) { WinrmCommunicator.new(
+          'test.host.name', nil, 'port' => 1234, 'transport' => 'test_transport', foo: 'bar', 'baz' => 'quaz')
+        }
+
+        before do
+          allow(rspec_configuration).to receive(:ssh)
+        end
+
+        shared_context 'existing session' do |endpoint|
+          before do
+            allow(rspec_configuration).to receive(:winrm).and_return(winrm_session)
+            allow(winrm_session).to receive(:endpoint).and_return(endpoint)
+          end
+        end
+
+        context 'existing ssh session' do
+          let(:ssh_session) {double('ssh session')}
+          before do
+            allow(rspec_configuration).to receive(:ssh).and_return(ssh_session)
+            allow(rspec_configuration).to receive(:winrm).and_return(nil)
+            allow(ssh_session).to receive(:host)
+            allow(ssh_session).to receive(:options).and_return({})
+            expect(ssh_session).to receive(:close)
+            expect(rspec_configuration).to receive(:ssh=).with(nil)
+          end
+
+          include_examples 'creating new session', 'test.host.name', 1234, :test_transport, {foo: 'bar', baz: 'quaz'}
+        end
+
+        context 'no existing session' do
+          before do
+            allow(rspec_configuration).to receive(:winrm).and_return(nil)
+          end
+
+          include_examples 'creating new session', 'test.host.name', 1234, :test_transport, {foo: 'bar', baz: 'quaz'}
+        end
+
+        context 'existing session with different endpoint' do
+          include_context 'existing session', 'http://test.another.host.name:1234/wsman'
+          include_examples 'creating new session', 'test.host.name', 1234, :test_transport, {foo: 'bar', baz: 'quaz'}
+        end
+
+        context 'existing session with same connection' do
+          include_context 'existing session', "http://test.host.name:1234/wsman"
+
+          it 'does not change the current rspec configuration' do
+            expect(WinRM::WinRMWebService).not_to receive(:new)
+            expect(rspec_configuration).not_to receive(:winrm=)
+            expect(rspec_configuration).not_to receive(:host=)
+      
+            subject.bind_to(rspec_configuration)
+
+            expect(subject.session).to eq(winrm_session)
+          end
+        end
+      end
+
+      it 'provides a remote backend' do
+        expect(WinrmCommunicator.new('test.host.name')).to be_a(RemoteBackend)
+      end
+
+      describe '#initialize' do
+        [nil, 'Test OS'].each do |os|
+          it 'holds the os information' do
+            expect(WinrmCommunicator.new('test.host.name', os, {}).os).to eq os
+          end
+        end
+      end
+    end
+  end
+end

data/spec/communication_adapters/winrm_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'nodespec/communication_adapters/winrm'
+
+module NodeSpec
+  module CommunicationAdapters
+    describe Winrm do
+      include_context 'new_winrm_communicator', 'test.host.name', 'test_os', {'foo' => 'bar'}
+
+      it 'returns communicator with the host name from the node name' do
+        expect(Winrm.communicator_for('test.host.name', 'test_os', 'foo' => 'bar')).to eq('winrm communicator')
+      end
+
+      it 'returns communicator with the host name from the options' do
+        expect(Winrm.communicator_for('test_node', 'test_os', 'host' => 'test.host.name', 'foo' => 'bar')).to eq('winrm communicator')
+      end
+    end
+  end
+end

data/spec/communication_adapters_spec.rb

@@ -0,0 +1,29 @@
+require 'nodespec/communication_adapters'
+%w[vagrant ssh aws_ec2 winrm].each {|f| require "nodespec/communication_adapters/#{f}"}
+
+module NodeSpec
+  describe CommunicationAdapters do
+    {
+      'vagrant' => CommunicationAdapters::Vagrant,
+      'ssh'     => CommunicationAdapters::Ssh,
+      'aws_ec2' => CommunicationAdapters::AwsEc2,
+      'winrm'   => CommunicationAdapters::Winrm
+    }.each do |adapter_name, adapter_class|
+      it "retrieves a communicator from #{adapter_class}" do
+        expect(adapter_class).to receive(:communicator_for).with('test_node', 'test_os', 'adapter_options' => 'test_options').and_return('communicator')
+
+        communicator = CommunicationAdapters.get_communicator('test_node', 'test_os', adapter_name, 'adapter_options' => 'test_options')
+
+        expect(communicator).to eq('communicator')
+      end
+    end
+
+    it 'defaults to a NativeCommunicator' do
+      expect(CommunicationAdapters::NativeCommunicator).to receive(:new).with('test_os').and_return('communicator')
+
+      communicator = CommunicationAdapters.get_communicator('test_node', 'test_os', nil)
+
+      expect(communicator).to eq('communicator')
+    end
+  end
+end

data/spec/local_command_runner_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'nodespec/local_command_runner'
+
+module NodeSpec
+  describe LocalCommandRunner do
+    let(:subject) {Object.new.extend LocalCommandRunner}
+    let(:cmd_status) { double('status') }
+
+    before do
+      allow(Open3).to receive(:capture2e).with('test command').and_return(['test output', cmd_status])
+      allow(subject).to receive(:execute_within_timeout).with('test command').and_yield
+    end
+
+    it 'returns true if the command succeeds' do
+      allow(cmd_status).to receive(:success?).and_return(true)
+      
+      expect(subject.run_command('test command')).to be_truthy
+    end
+
+    it 'returns false if the command fails' do
+      allow(cmd_status).to receive(:success?).and_return(false)
+      
+      expect(subject.run_command('test command')).to be_falsy
+    end
+  end
+end