boris 1.0.0.beta.1 → 1.0.1

data/test/setup_tests.rb

@@ -1,14 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
-
-require 'test/unit'
-require 'shoulda'
-require 'boris'
-
-include Boris
-
-class ProfileTestSetup < Test::Unit::TestCase
-  def initialize(test)
-    super(test)
-    @target = Target.new('0.0.0.0')
-  end
-end

data/test/test_all.rb

@@ -1,8 +0,0 @@
-$: << '.'
-
-Dir.chdir(File.dirname(__FILE__)) do
-  test_files = Dir['test_*.rb'] - [('test_all.rb')]
-  test_files.concat(Dir['**/test_*.rb'])
-
-  test_files.each { |file| require file }
-end

data/test/test_options.rb

@@ -1,44 +0,0 @@
-require 'setup_tests'
-
-class OptionsTest < Test::Unit::TestCase
-  context 'the options for a Target' do
-    setup do
-      @options = Options.new
-    end
-
-    should 'be modifiable via the options hash' do
-      @options[:auto_scrub_data] = false
-      @options[:credentials] = [{:user=>'someuser'}]
-      @options[:log_level] = Logger::INFO
-      @options[:profiles] = [:windows_core]
-      @options[:snmp_options] = {:MibModules=>['IF-MIB']}
-      @options[:ssh_options] = {:keys=>'~/.ssh/my_private_key', :verbose=>:debug}
-
-      assert_equal(false, @options[:auto_scrub_data])
-      assert_equal([{:user=>'someuser'}], @options[:credentials])
-      assert_equal(Logger::INFO, @options[:log_level])
-      assert_equal([:windows_core], @options[:profiles])
-      assert_equal({:MibModules=>['IF-MIB']}, @options[:snmp_options])
-      assert_equal({:keys=>'~/.ssh/my_private_key', :verbose=>:debug}, @options[:ssh_options])
-    end
-
-    should 'error if invalid options are provided' do
-      assert_raise(ArgumentError) {@options[:invalid_option] = nil}
-    end
-
-    should 'error if invalid options are passed to #add_credential' do
-      assert_raise(ArgumentError) {@options.add_credential(:password=>'somepass')}
-      assert_raise(ArgumentError) {@options.add_credential(:user=>'someuser', :connection_types=>[:i_dont_exist])}
-      assert_raise(ArgumentError) {@options.add_credential([{:user=>'someuser1'},{:user=>'someuser2'}])}
-    end
-
-    should 'allow its credentials be added through #add_credential' do
-      @options.add_credential(:user=>'someuser', :password=>'somepass', :connection_types=>[:wmi])
-      @options.add_credential(:user=>'someotheruser', :connection_types=>[:ssh])
-      assert_equal([
-        {:user=>'someuser', :password=>'somepass', :connection_types=>[:wmi]},
-        {:user=>'someotheruser', :connection_types=>[:ssh]}
-      ], @options[:credentials])
-    end
-  end
-end

data/test/test_structure.rb

@@ -1,136 +0,0 @@
-require 'setup_tests'
-
-class ProfileStructure
-  include Profiles::Structure
-  attr_accessor :logger, :options
-end
-
-class StructureTest < Test::Unit::TestCase
-  context 'a data structure' do
-    setup do
-      @structure = ProfileStructure.new
-      @structure.options = Options.new
-    end
-
-    should 'provide us with a file system template via #file_system_template' do
-      expected = [
-        :capacity_mb,
-        :file_system,
-        :mount_point,
-        :san_storage,
-        :used_space_mb
-      ].to_nil_hash
-
-      assert_equal(expected, @structure.file_system_template)
-    end
-
-    should 'provide us with a hardware template via #get_hardware' do
-      expected = [
-        :cpu_architecture,
-        :cpu_core_count,
-        :cpu_model,
-        :cpu_physical_count,
-        :cpu_speed_mhz,
-        :cpu_vendor,
-        :firmware_version,
-        :model,
-        :memory_installed_mb,
-        :serial,
-        :vendor
-      ].to_nil_hash
-
-      assert_equal(expected, @structure.get_hardware)
-    end
-
-    should 'provide us with an installed application template via #installed_application_template' do
-      expected = [
-        :date_installed,
-        :install_location,
-        :license_key,
-        :name,
-        :vendor,
-        :version
-      ].to_nil_hash
-
-      assert_equal(expected, @structure.installed_application_template)
-    end
-
-    should 'provide us with a local user groups template via #local_user_groups_template' do
-      expected = {
-        :group=>nil,
-        :members=>[]
-      }
-      
-      assert_equal(expected, @structure.local_user_groups_template)
-    end
-
-    should 'provide us with a network identification template via #get_network_id' do
-      expected = [
-        :domain,
-        :hostname
-      ].to_nil_hash
-
-      assert_equal(expected, @structure.get_network_id)
-    end
-
-    should 'provide us with a network interface template via #network_interface_template' do
-      expected = [
-        :auto_negotiate,
-        :current_speed_mbps,
-        :duplex,
-        :fabric_name,
-        :is_uplink,
-        :mac_address,
-        :model,
-        :model_id,
-        :mtu,
-        :name,
-        :node_wwn,
-        :port_wwn,
-        :remote_mac_address,
-        :status,
-        :type,
-        :vendor,
-        :vendor_id,
-        :dns_servers=>[],
-        :ip_addresses=>[]
-      ].to_nil_hash
-      
-      assert_equal(expected, @structure.network_interface_template)
-    end
-
-    should 'provide us with an operating system template via #get_operating_system' do
-      expected = [
-        :date_installed,
-        :kernel,
-        :license_key,
-        :name,
-        :service_pack,
-        :version,
-        :features=>[],
-        :roles=>[]
-      ].to_nil_hash
-      
-      assert_equal(expected, @structure.get_operating_system)
-    end
-
-    should 'provide us with a patch template via #installed_patch_template' do
-      expected = [
-        :date_installed,
-        :installed_by,
-        :patch_code        
-      ].to_nil_hash
-
-      assert_equal(expected, @structure.installed_patch_template)
-    end
-
-    should 'provide us with a share template via #hosted_share_template' do
-      expected = [
-        :name,
-        :path
-      ].to_nil_hash
-
-      assert_equal(expected, @structure.hosted_share_template)
-    end
-  end
-end

data/test/test_target.rb

@@ -1,146 +0,0 @@
-require 'setup_tests'
-
-class TargetTest < Test::Unit::TestCase
-  context 'a Target' do
-    setup do
-      @target = Target.new('0.0.0.0')
-      @target.extend(Profiles::Structure)
-      @cred = {:user=>'someuser', :password=>'somepass'}
-    end
-
-    should 'return host info after calling #load_host_info' do
-      @target.expects(:load_host_info).returns([@host, nil])
-      assert_equal(@target.load_host_info, [@host, nil])
-    end
-
-    should 'allow its target name to be readable' do
-      assert_equal('0.0.0.0', @target.host)
-    end
-
-    should 'allow its options to be modifiable by passing a block to Target#new' do
-      Target.new(@host) do |t|
-        t.options[:ssh_options] = {:timeout=>10}
-
-        assert_equal({:timeout=>10}, t.options[:ssh_options])
-      end
-    end
-
-    should 'allow us to call methods for retrieving all standard configuration items via #retrieve_all' do
-      @target.options[:auto_scrub_data] = false
-      @target.retrieve_all
-
-      assert_equal([], @target.file_systems)
-      assert_equal([], @target.installed_applications)
-      assert_equal([], @target.local_user_groups)
-      assert_equal([], @target.network_interfaces)
-      assert_equal([], @target.installed_patches)
-      assert_equal([], @target.hosted_shares)
-    end
-
-    should 'allow its data (instance variables) to be produced as json' do
-      long_json_string = %w{
-        {"file_systems":null,
-        "hardware":null,
-        "hosted_shares":null,
-        "installed_applications":null,
-        "installed_patches":null,
-        "installed_services":null,
-        "local_user_groups":null,
-        "network_id":null,
-        "network_interfaces":null,
-        "operating_system":null}}.join
-
-      assert_equal(long_json_string, @target.to_json)
-    end
-
-
-    should 'allow credentials to be added through #add_credential' do
-      @target.options.add_credential(@cred.merge!(:connection_types=>[:wmi]))
-      assert_equal([@cred], @target.options[:credentials])
-    end
-
-    context 'listening on certain ports' do
-      should "allow us to detect a possible SSH connection if it is listening on port #{Boris::PORT_DEFAULTS[:ssh]}" do
-        @target.expects(:tcp_port_responding?).with(22).returns(true)
-        @target.expects(:tcp_port_responding?).with(135).returns(false)
-        assert_equal(:ssh, @target.suggested_connection_method)
-      end
-
-      should "allow us to detect a possible WMI connection if if it is listening on port #{Boris::PORT_DEFAULTS[:wmi]}" do
-        @target.expects(:tcp_port_responding?).with(135).returns(true)
-        assert_equal(:wmi, @target.suggested_connection_method)
-      end
-
-      should 'return with no detected connection method if all attempts fail' do
-        @target.expects(:tcp_port_responding?).with(22).returns(false)
-        @target.expects(:tcp_port_responding?).with(135).returns(false)
-        assert_nil(nil, @target.suggested_connection_method)
-      end
-    end
-
-    context 'that we will try to connect to' do
-      should 'error if no credentials are specified' do
-        assert_raise(InvalidOption) {@target.connect}
-      end
-
-      should 'error if we try to detect the profile when there is no active connection' do
-        assert_raise(NoActiveConnection) {@target.detect_profile}
-      end
-
-      should 'attempt an SSH and WMI connection only once if the target does not respond to an attempt' do
-        skip("test relies on WIN32OLE") if PLATFORM != :win32
-        
-        @target.options.add_credential(@cred.merge!(:connection_types=>[:snmp, :ssh, :wmi]))
-        
-        Net::SSH.stubs(:start).raises(Net::SSH::HostKeyMismatch)
-        WIN32OLE.any_instance.stubs(:ConnectServer).raises(WIN32OLERuntimeError, 'rpc server is unavailable')
-
-        SSHConnector.any_instance.expects(:establish_connection).once
-        WMIConnector.any_instance.expects(:establish_connection).once
-
-        @target.connect
-      end
-
-      should 'attempt a connection only once when connection is not available and when multiple credentials are supplied' do
-        @target.options[:credentials] = [@cred.merge(:connection_types=>[:ssh])]
-        @target.options[:credentials] << @cred.merge(:connection_types=>[:ssh])
-
-        SSHConnector.any_instance.stubs(:reconnectable).returns(false)
-        SSHConnector.any_instance.expects(:establish_connection).once
-
-        @target.connect
-      end
-    end
-
-    context 'that we have successfully connected to' do
-      setup do
-        ssh_connection = mock('SSHConnector')
-        @target.connector = ssh_connection
-
-        @target.connector.stubs(:connected?).returns(true)
-        @target.connector.stubs(:class).returns(Connector::SSHConnector)
-        @target.stubs(:connect).returns(@target.connector)
-
-        @target.options[:profiles].each do |profile|
-          profile.stubs(:matches_target?).returns(false)
-        end
-
-        @target.connect
-      end
-
-      should 'raise an error if no profiles are found to be suitable' do
-        assert_raise(NoProfileDetected) {@target.detect_profile}
-      end
-
-      should 'detect the best profile for our target' do
-        Profiles::RedHat.stubs(:matches_target?).returns(true)
-        assert_equal(Profiles::RedHat, @target.detect_profile)
-      end
-
-      should 'allow us to force a profile to be used for our target even if it is not ideal' do
-        @target.force_profile_to(Profiles::RedHat)
-        assert_equal(Profiles::RedHat, @target.target_profile)
-      end
-    end
-  end
-end