nodespec 0.1.10 → 1.0.0

data/spec/backend_proxy/ssh_spec.rb

@@ -4,27 +4,27 @@ module NodeSpec
   module BackendProxy
     describe Ssh do
       let(:ssh_session) { double('ssh session') }
-      let(:subject) {Ssh.new(ssh_session)}
+      subject {Ssh.new(ssh_session)}
 
       shared_examples 'an ssh session command run' do |user, original_command, actual_command|
         before do
           allow(ssh_session).to receive(:options).and_return({user: user})
           allow(subject).to receive(:execute_within_timeout).with(actual_command).and_yield
         end
-        
+
         it 'returns true if the command succeeds' do
           allow(ssh_session).to receive(:exec!).with(actual_command).and_yield(nil, 'a stream', 'test data')
-          
+
           expect(subject.execute(original_command)).to be_truthy
         end
 
         it 'returns false if the command fails' do
           allow(ssh_session).to receive(:exec!).with(actual_command).and_yield(nil, :stderr, 'test data')
-          
+
           expect(subject.execute(original_command)).to be_falsy
         end
       end
-      
+
       it_behaves_like 'an ssh session command run', 'root', 'test command', 'test command'
       it_behaves_like 'an ssh session command run', 'some_user', 'test command', 'sudo test command'
     end

data/spec/backend_proxy/unixshell_utility_spec.rb

@@ -3,7 +3,7 @@ require 'nodespec/backend_proxy/unixshell_utility'
 module NodeSpec
   module BackendProxy
     describe UnixshellUtility do
-      let(:subject) {Object.new.extend UnixshellUtility}
+      subject {Object.new.extend UnixshellUtility}
 
       it 'returns the command as run by sudo' do
         expect(subject.run_as_sudo('command')).to eq 'sudo command'

data/spec/backend_proxy/winrm_spec.rb

@@ -2,9 +2,9 @@ require 'nodespec/backend_proxy/winrm'
 
 module NodeSpec
   module BackendProxy
-    describe WinRM do
+    describe Winrm do
       let(:winrm) { double('winrm session') }
-      let(:subject) {WinRM.new(winrm)}
+      subject {Winrm.new(winrm)}
       before do
         allow(winrm).to receive(:set_timeout).with(NodeSpec::RunOptions.command_timeout)
       end

data/spec/command_execution_spec.rb

@@ -2,8 +2,8 @@ require 'nodespec/command_execution'
 
 module NodeSpec
   describe CommandExecution do
-    let(:subject) {Object.new.extend CommandExecution}
-    
+    subject {Object.new.extend CommandExecution}
+
     it 'does not raise an error if the command succeeds' do
       subject.execute_within_timeout('test command') { true }
     end

data/spec/communication_adapters/aws_ec2_spec.rb

@@ -17,28 +17,28 @@ module NodeSpec
         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')
+          allow(ec2_instance).to receive(:public_dns_name).ordered.and_return('test.host.name')
         end
 
         %w[ssh winrm].each do |connection|
           describe "#{connection} communicator" do
-            include_context "new_#{connection}_communicator", 'test hostname', 'test_os', 'foo' => 'bar'
+            include_context "new_#{connection}_communicator", 'test.host.name', '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")
+              expect(AwsEc2.communicator_for('test-instance', 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")
+              expect(AwsEc2.communicator_for('test_node', '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', {}
+          include_context "new_ssh_communicator", 'test.host.name', {}
 
           it 'returns an ssh communicator' do
-            expect(AwsEc2.communicator_for('test-instance', 'test_os')).to eq("ssh communicator")
+            expect(AwsEc2.communicator_for('test-instance')).to eq("ssh communicator")
           end
         end
       end
@@ -50,7 +50,7 @@ module NodeSpec
           end
 
           it 'raises an error' do
-            expect {AwsEc2.communicator_for('test-instance', 'test_os', 'foo' => 'bar')}.to raise_error
+            expect {AwsEc2.communicator_for('test-instance', 'foo' => 'bar')}.to raise_error
           end
         end
 
@@ -61,7 +61,7 @@ module NodeSpec
           end
 
           it 'raises an error' do
-            expect {AwsEc2.communicator_for('test-instance', 'test_os', 'foo' => 'bar')}.to raise_error
+            expect {AwsEc2.communicator_for('test-instance', 'foo' => 'bar')}.to raise_error
           end
         end
       end

data/spec/communication_adapters/native_communicator_spec.rb

@@ -1,51 +1,33 @@
+require 'spec_helper'
 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
+      describe 'providing backend proxy' do
+        context 'non Windows os' do
+          before do
+            allow(OS).to receive(:windows?).and_return(false)
           end
+          include_examples 'providing a backend', :exec, BackendProxy::Exec
         end
-      end
-
-      describe '#bind_to' do
-        let(:rspec_configuration) {double('rspec configuration')}
-
-        context('ssh session') do
-          let(:ssh_session) {double('ssh session')}
 
+        context 'Windows os' do
           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)
+            allow(OS).to receive(:windows?).and_return(true)
           end
 
-          it 'closes and removes an existing ssh session' do
-            subject.bind_to(rspec_configuration)
-          end
+          include_examples 'providing a backend', :cmd, BackendProxy::Cmd
         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
+      describe '#bind_to' do
+        let(:configuration) {double('configuration')}
 
-          it 'removes an existing winrm session' do
-            subject.bind_to(rspec_configuration)
-          end
+        it 'unbinds other sessions' do
+          expect(configuration).to receive(:unbind_ssh_session)
+          expect(configuration).to receive(:unbind_winrm_session)
+          subject.bind_to(configuration)
         end
       end
     end

data/spec/communication_adapters/ssh_communicator_spec.rb

@@ -1,120 +1,64 @@
+require 'spec_helper'
 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')}
+      let(:configuration) {double('configuration')}
 
-      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|
+      shared_context 'creating new session' do |hostname, options|
         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})
+          expect(configuration).to receive(:unbind_winrm_session)
+          allow(Net::SSH).to receive(:start).with(hostname, 'testuser', options).and_return('session')
+          allow(configuration).to receive(:bind_ssh_session_for) do |host, port, &block|
+            expect(host).to eq hostname
+            expect(port).to eq port
+            block.call
+          end
         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)
+      shared_examples 'binding session' do
+        it 'returns a session' do
+          subject.bind_to(configuration)
 
-          expect(subject.session).to eq('new session')
+          expect(subject.session).to eq('session')
         end
       end
 
-      shared_examples 'binding to configuration' do
-        before do
-          allow(rspec_configuration).to receive(:winrm)
-        end
-
-        context 'existing winrm session' do
+      describe 'binding the session' do
+        context 'default options' do
+          subject {SshCommunicator.new('test.host.name')}
           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)
+            allow(Net::SSH).to receive(:configuration_for).and_return({someoption: 'somevalue', user: 'testuser'})
           end
-
-          include_examples 'creating new session'
+          include_context 'creating new session', 'test.host.name', someoption: 'somevalue', user: 'testuser'
+          include_examples 'binding session'
         end
 
-        context 'no existing ssh session' do
+        context 'custom options' do
+          subject {SshCommunicator.new('test.host.name', 'port' => 1234, 'user' => 'testuser', 'password' => 'testpassword', 'keys' => 'testkeys')}
           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'
+            allow(Net::SSH).to receive(:configuration_for).and_return({someoption: 'somevalue', port: 22, user: 'testuser'})
           end
+          include_context 'creating new session', 'test.host.name', someoption: 'somevalue', port: 1234, user: 'testuser', password: 'testpassword', keys: 'testkeys'
+          include_examples 'binding session'
         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'
+        context 'same session' do
+          subject {SshCommunicator.new('test.host.name', 'port' => 1234, 'user' => 'testuser')}
+          before do
+            expect(configuration).to receive(:unbind_winrm_session)
+            allow(configuration).to receive(:bind_ssh_session_for).with('test.host.name', 1234).and_return('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({})
+          include_examples 'binding session'
         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
+      describe 'providing backend proxy' do
+        subject {SshCommunicator.new('test.host.name')}
+        include_examples 'providing a backend', :ssh, BackendProxy::Ssh
       end
     end
   end

data/spec/communication_adapters/ssh_spec.rb

@@ -4,15 +4,7 @@ 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
+      include_examples 'new_communicator', Ssh, 'ssh'
     end
   end
 end

data/spec/communication_adapters/vagrant_spec.rb

@@ -4,7 +4,7 @@ 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|
+      [['test_vm', 'test_os'], ['test_node', {'vm_name' => 'test_vm'}]].each do |args|
         describe "#communicator_for" do
           let(:cmd_status) { double('status') }
 
@@ -40,7 +40,7 @@ Host test_vm
 EOS
             }
 
-            include_context 'new_ssh_communicator', 'test.host.name', 'test_os', {
+            include_context 'new_ssh_communicator', 'test.host.name', {
               'user' => 'testuser',
               'port' => 1234,
               'keys' => '/test/path/private_key'

data/spec/communication_adapters/winrm_communicator_spec.rb

@@ -1,110 +1,58 @@
-require 'winrm'
+require 'spec_helper'
 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|
+      let(:configuration) {double('configuration')}
+
+      shared_context '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)
+          expect(configuration).to receive(:unbind_ssh_session)
+          allow(WinRM::WinRMWebService).to receive(:new).with("http://#{hostname}:#{port}/wsman", transport, options).and_return('session')
+          allow(configuration).to receive(:bind_winrm_session_for) do |host, endpoint, &block|
+            expect(host).to eq hostname
+            expect(endpoint).to eq "http://#{hostname}:#{port}/wsman"
+            block.call
+          end
         end
+      end
 
-        it 'creates and holds a new session' do
-          subject.bind_to(rspec_configuration)
+      shared_examples 'binding session' do
+        it 'returns a session' do
+          subject.bind_to(configuration)
 
-          expect(subject.session).to eq('new session')
+          expect(subject.session).to eq('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
-
+      describe 'binding the session' do
         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}
+          subject {WinrmCommunicator.new('test.host.name', 'foo' => 'bar')}
+          include_context 'creating new session', 'test.host.name', 5985, :plaintext, {foo: 'bar', disable_sspi: true}
+          include_examples 'binding session'
         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
+          subject {WinrmCommunicator.new('test.host.name', 'port' => 1234, 'transport' => 'test_transport', 'foo' => 'bar')}
+          include_context 'creating new session', 'test.host.name', 1234, :test_transport, {foo: 'bar'}
+          include_examples 'binding session'
         end
 
-        context 'existing ssh session' do
-          let(:ssh_session) {double('ssh session')}
+        context 'same session' do
+          subject {WinrmCommunicator.new('test.host.name', 'foo' => 'bar')}
           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)
+            expect(configuration).to receive(:unbind_ssh_session)
+            allow(configuration).to receive(:bind_winrm_session_for).with('test.host.name', "http://test.host.name:5985/wsman").and_return('session')
           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
+          include_examples 'binding session'
         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
+      describe 'providing backend proxy' do
+        subject {WinrmCommunicator.new('test.host.name')}
+        include_examples 'providing a backend', :winrm, BackendProxy::Winrm
       end
     end
   end

data/spec/communication_adapters/winrm_spec.rb

@@ -4,15 +4,7 @@ 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
+      include_examples 'new_communicator', Winrm, 'winrm'
     end
   end
 end

data/spec/communication_adapters_spec.rb

@@ -10,18 +10,18 @@ module NodeSpec
       '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')
+        expect(adapter_class).to receive(:communicator_for).with('test_node', 'adapter_options' => 'test_options').and_return('communicator')
 
-        communicator = CommunicationAdapters.get_communicator('test_node', 'test_os', adapter_name, 'adapter_options' => 'test_options')
+        communicator = CommunicationAdapters.get_communicator('test_node', 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')
+      expect(CommunicationAdapters::NativeCommunicator).to receive(:new).and_return('communicator')
 
-      communicator = CommunicationAdapters.get_communicator('test_node', 'test_os', nil)
+      communicator = CommunicationAdapters.get_communicator('test_node')
 
       expect(communicator).to eq('communicator')
     end