boris 1.0.0.beta.1

data/test/connector_tests/test_snmp.rb

@@ -0,0 +1,35 @@
+require 'ostruct'
+require 'setup_tests'
+
+class SNMPTest < Test::Unit::TestCase
+  context 'a target listening for SNMP requests' do
+    setup do
+      @target_name = '0.0.0.0'
+      @cred = {:user=>'someuser', :password=>'somepass'}
+      @connector = SNMPConnector.new(@target_name, @cred, Options.new)
+
+      @transport = mock('SNMP')
+
+      SNMP::Manager.stubs(:new).returns(@transport)
+
+      @expected_value = {:name=>'sysDescr.0', :value=>'string'}
+
+      @transport.stubs(:walk).with('sysDescr').yields([OpenStruct.new(@expected_value)])
+    end
+
+    should 'allow us to connect to it' do
+      assert_kind_of(SNMPConnector, @connector.establish_connection)
+    end
+
+    context 'to which we have already connected' do
+      setup do
+        @connector.establish_connection
+      end
+
+      should 'allow us to perform a simple SNMP GET' do
+        assert_equal(@expected_value, @connector.value_at('sysDescr'))
+        assert_equal([@expected_value], @connector.values_at('sysDescr'))
+      end
+    end
+  end
+end

data/test/connector_tests/test_ssh.rb

@@ -0,0 +1,51 @@
+require 'setup_tests'
+
+class SSHTest < Test::Unit::TestCase
+  context 'a target listening for SSH connections' do
+    setup do
+      @target_name = '0.0.0.0'
+      @cred = {:user=>'someuser', :password=>'somepass'}
+      @connector = SSHConnector.new(@target_name, @cred, Options.new)
+
+      @transport = mock('SSHConnector')
+
+      Net::SSH.stubs(:start).returns(@transport)
+
+      @expected_data = 'SunOS'
+    end
+
+    should 'allow us to connect to it via SSH' do
+      assert_kind_of(SSHConnector, @connector.establish_connection)
+    end
+
+    context 'to which we have already connected' do
+      setup do
+        @connector.establish_connection
+
+        @channel = mock('channel')
+        @transport.stubs(:open_channel).returns(@channel).then.yields(@channel)
+        @channel.stubs(:on_data).yields(@channel, @expected_data)
+        @channel.stubs(:on_extended_data).returns(@channel)
+        @channel.stubs(:on_close).returns
+        @channel.expects(:exec).at_least_once
+        @channel.expects(:wait).at_least_once
+      end
+
+      should 'allow us to retrieve data' do
+        assert_equal(@expected_data, @connector.value_at('uname'))
+        assert_equal([@expected_data], @connector.values_at('uname'))
+      end
+
+      # should 'reconnect if a channel was closed prematurely' do
+      #   @connector.expects(:establish_connection).once #more
+      #   @channel.stubs(:on_close).yields(@channel)
+      #   assert_equal(@expected_data, @connector.value_at('uname'))
+      # end
+
+      should 'request pty if needed' do
+        @channel.expects(:request_pty).once
+        assert_equal(@expected_data, @connector.value_at('uname', true))
+      end
+    end
+  end
+end

data/test/connector_tests/test_wmi.rb

@@ -0,0 +1,129 @@
+require 'setup_tests'
+
+class WMITest < Test::Unit::TestCase
+  context 'a target listening for WMI connections' do
+    setup do
+      skip("test relies on WIN32OLE")
+      
+      @target_name = '0.0.0.0'
+      @cred = {:user=>'someuser', :password=>'somepass'}
+      @connector = WMIConnector.new(@target_name, @cred, Options.new)
+
+      @win32ole = mock('WIN32OLE')
+
+      WIN32OLE.stubs(:new).with('WbemScripting.SWbemLocator').returns(@win32ole)
+
+      ['root\cimv2', 'root\WMI', 'root\default'].each do |namespace|
+        @win32ole.stubs(:ConnectServer).with(@target_name, namespace, @cred[:user], @cred[:password], nil, nil, 128).returns(@win32ole)
+      end
+      @win32ole.stubs(:Get).with('StdRegProv').returns(@win32ole)
+      
+      @connector.establish_connection
+    end
+
+    context 'to which we have already connected' do
+      setup do
+        @row = mock('row')
+        
+        @property = mock('property')
+
+        @win32ole.stubs(:ExecQuery).returns([@row])
+        @row.stubs(:Properties_).returns([@property])
+      end
+
+      should 'allow us to get property values with a wmi query from the cimv2 namespace via #execute' do
+        @property.stubs(:Name).returns('Name')
+        @property.stubs(:Value).returns('Windows Server 2008')
+        assert_equal({:name=>'Windows Server 2008'}, @connector.value_at('SELECT Name FROM Win32_OperatingSystem'))
+      end
+
+      should 'allow us to get property values with a wmi query from the root wmi namespace via #execute' do
+        @property.stubs(:Name).returns('InstanceName')
+        @property.stubs(:Value).returns('VMware Accelerated AMD PCNet Adapter')
+        assert_equal([:instancename=>'VMware Accelerated AMD PCNet Adapter'], @connector.values_at('SELECT * FROM MSNdis_HardwareStatus', :root_wmi))
+      end
+
+      should 'allow us to get attribute values from a wmi query via #execute' do
+        attribute = mock('attribute')
+        @row.stubs(:Attributes).returns(attribute)
+        attribute.stubs(:Properties_).returns([@property])
+        
+        @property.stubs(:Name).returns('PortType')
+        @property.stubs(:Value).returns(1)
+
+        assert_equal([:porttype=>1], @connector.values_at('SELECT * FROM MSFC_FibrePortHBAAttributes', :root_wmi))
+      end
+
+      should 'error if an invalid limit for query is specified' do
+        assert_raise(ArgumentError) {@connector.values_at('select * from something', nil, '5')}
+      end
+    end
+
+    context 'to which we want to connect via the registry namespace' do
+      setup do
+        #@target.connect
+
+        win32ole = mock('win32ole')
+
+        @registry = @connector.registry = win32ole
+        @registry.stubs(:Methods_).returns(win32ole)
+        @registry.stubs(:inParameters).returns(win32ole)
+        @registry.stubs(:SpawnInstance_).returns(win32ole)
+        @registry.stubs(:ExecMethod_).returns(win32ole)
+        @registry.stubs(:hDefKey=)
+        @registry.stubs(:sSubKeyName=)
+      end
+
+      should 'allow us to see if we have permissions to read certain registry keys via #has_access_for' do
+        @registry.stubs(:uRequired=)
+        @registry.stubs(:bGranted).returns(true)
+
+        assert(@connector.has_access_for('HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT'))
+      end
+
+      should 'allow us to access registry keys via #subkeys_at' do
+        @connector.stubs(:has_access_for).returns(true)
+        
+        @registry.stubs(:sNames).returns(['CurrentVersion'])
+
+        expected_data = ['HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion']
+
+        assert_equal(expected_data, @connector.registry_subkeys_at('HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT'))
+      end
+
+      context 'and read values' do
+        setup do
+          @key_path = 'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion'
+          @connector.stubs(:has_access_for).returns(true)
+          @registry.stubs(:sValueName=)
+          @expected_data = {}
+        end
+
+        should 'return an empty hash from #values_at when the path does not exist' do
+          @registry.stubs(:sNames).returns([])
+
+          @expected_data[:key_path] = 'HKEY_LOCAL_MACHINE\i\dont\exist'
+          assert_equal({}, @connector.registry_values_at(@expected_data[:key_path]))
+        end
+
+        should 'allow us to access string values from the registry via #values_at' do
+          @registry.stubs(:sNames).returns(['ProductName'])
+          @registry.stubs(:sValue).returns('Microsoft Windows Server 2008 R2')
+          @registry.stubs(:uValue).returns(nil)
+
+          @expected_data = {:productname=>'Microsoft Windows Server 2008 R2'}
+          assert_equal(@expected_data, @connector.registry_values_at(@key_path))
+        end
+
+        should 'allow us to access other values from the registry via #values_at' do
+          @registry.stubs(:sNames).returns(['InstallDate'])
+          @registry.stubs(:sValue).returns(nil)
+          @registry.stubs(:uValue).returns(123456)
+
+          @expected_data = {:installdate=>123456}
+          assert_equal(@expected_data, @connector.registry_values_at(@key_path))
+        end
+      end
+    end
+  end
+end

data/test/helper_tests/test_array.rb

@@ -0,0 +1,25 @@
+require 'setup_tests'
+
+class ArrayTest < Test::Unit::TestCase
+  context 'the Array class' do
+    should 'return the product key for a microsoft product via #to_ms_product_key' do
+      product_key_binary = [164, 1, 1, 0, 3, 0, 0, 0, 53, 53, 48, 52, 49, 45, 49, 56, 54, 45, 48, 49, 51, 51, 48,
+        51, 53, 45, 55, 53, 55, 54, 51, 0, 151, 0, 0, 0, 88, 49, 52, 45, 50, 51, 56, 57, 54, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+      assert_equal('BBBBB-BBBBB-BBBBB-BBBBB-BBBBB', product_key_binary.to_ms_product_key)
+    end
+
+    should 'return each item of an array as a nil-values key-value pair via #to_nil_hash' do
+      assert_equal({:value_one=>nil, :value_two=>nil}, ['value_one', 'value_two'].to_nil_hash)
+    end
+
+    should 'return the wwn of an array via #to_wwn' do
+      assert_equal('00000000aaaaaaaa', [0, 0, 0, 0, 170, 170, 170, 170].to_wwn)
+    end
+
+    should 'recursively strip the string values within an array via #strip_string_values_in_array' do
+      assert_equal([1, 'a', 'c', ['x', 'y']], [1, 'a ', ' c ', [' x ', ' y ']].strip_string_values_in_array)
+    end
+  end
+end

data/test/helper_tests/test_hash.rb

@@ -0,0 +1,10 @@
+require 'setup_tests'
+
+class HashTest < Test::Unit::TestCase
+  context 'the Hash class' do
+    should 'recursivley strip the string values inside of a Hash via #strip_string_values_in_hash' do
+      assert_equal({:someval=>'strip this', :somearray=>['this too!']},
+        {:someval=>' strip this ', :somearray=>[' this too!']}.strip_string_values_in_hash)
+    end
+  end
+end

data/test/helper_tests/test_string.rb

@@ -0,0 +1,136 @@
+require 'setup_tests'
+
+class StringTest < Test::Unit::TestCase
+  context 'the String class' do
+    should 'return the last chunk of text after a colon via #after_colon' do
+      assert_equal('C', 'AB:C'.after_colon)
+      assert_equal('C', 'A:B:C'.after_colon)
+      assert_equal(nil, 'ABC'.after_colon)
+    end
+
+    should 'return the last chunk of text after a period via #after_period' do
+      assert_equal('C', 'AB.C'.after_period)
+      assert_equal('C', 'A.B.C'.after_period)
+      assert_equal(nil, 'ABC'.after_period)
+    end
+
+    should 'return the last chunk of text after a pipe via #after_pipe' do
+      assert_equal('C', 'AB|C'.after_pipe)
+      assert_equal('C', 'A|B|C'.after_pipe)
+      assert_equal(nil, 'ABC'.after_pipe)
+    end
+
+    should 'return the last chunk of text after a slash via #after_slash' do
+      assert_equal('C', 'A/B/C'.after_slash)
+      assert_equal('C', 'A\B\C'.after_slash)
+      assert_equal(nil, 'ABCD'.after_slash)
+    end
+
+    should 'return the first chunk of text before a colon via #before_colon' do
+      assert_equal('AB', 'AB:C'.before_colon)
+      assert_equal('A', 'A:B:C'.before_colon)
+      assert_equal(nil, 'ABC'.before_colon)
+    end
+
+    should 'return the first chunk of text before a period via #before_period' do
+      assert_equal('AB', 'AB.C'.before_period)
+      assert_equal('A', 'A.B.C'.before_period)
+      assert_equal(nil, 'ABC'.before_period)
+    end
+
+    should 'return the first chunk of text after a pipe via #before_pipe' do
+      assert_equal('AB', 'AB|C'.before_pipe)
+      assert_equal('A', 'A|B|C'.before_pipe)
+      assert_equal(nil, 'ABC'.before_pipe)
+    end
+
+    should 'return the first chunk of text after a slash via #before_slash' do
+      assert_equal('A', 'A/B/C'.before_slash)
+      assert_equal('A', 'A\B\C'.before_slash)
+      assert_equal(nil, 'ABCD'.before_slash)
+    end
+
+    should 'return the value between a pair of parenthesis via #between_parenthesis' do
+      assert_equal('a test string', 'this is (a test string)'.between_parenthesis)
+      assert_equal('', 'this is a test () string'.between_parenthesis)
+      assert_equal(nil, 'this is a test'.between_parenthesis)
+    end
+
+    should 'return the proper name of a model via #format_model' do
+      assert_equal('Product X 1000', 'Product X 1000 server'.format_model)
+      assert_equal('SunBlade 100', 'sun blade 100'.format_model)
+      assert_equal('SunFire 100', 'sun fire 100'.format_model)
+      assert_equal('SPARC Enterprise T1000', 'T1000'.format_model)
+      assert_equal('BIG-IP 1000', 'bigip 1000'.format_model)
+      assert_equal('Catalyst 1000', 'WSC1000'.format_model)
+      assert_equal('Catalyst 1000-E', 'WSC1000E'.format_model)
+      assert_equal('Catalyst 1000-E', 'WSC1000-E'.format_model)
+      assert_equal('System x1000 M3', 'IBM System x1000 M3'.format_model)
+      assert_equal('System x1000 M3', 'IBM System x1000 M3 -[123456]-'.format_model)
+    end
+
+    should 'return the proper serial number via #format_serial' do
+      assert_equal('ABC123', 'abc123'.format_serial)
+      assert_equal(nil, 'None'.format_serial)
+    end
+
+    should 'return the proper name of a vendor via #format_vendor' do
+      assert_equal(VENDOR_AMD, 'amd'.format_vendor)
+      assert_equal(VENDOR_AMD, 'authenticamd'.format_vendor)
+      assert_equal(VENDOR_BROCADE, 'brocade communications'.format_vendor)
+      assert_equal(VENDOR_CITRIX, 'citrix'.format_vendor)
+      assert_equal(VENDOR_DELL, 'dell'.format_vendor)
+      assert_equal(VENDOR_EMULEX, 'emulex'.format_vendor)
+      assert_equal(VENDOR_HP, 'compaq'.format_vendor)
+      assert_equal(VENDOR_HP, 'hp'.format_vendor)
+      assert_equal(VENDOR_HP, 'hp inc'.format_vendor)
+      assert_equal(VENDOR_HP, 'hewlett packard'.format_vendor)
+      assert_equal(VENDOR_IBM, 'ibm'.format_vendor)
+      assert_equal(VENDOR_INTEL, 'genuineintel'.format_vendor)
+      assert_equal(VENDOR_INTEL, 'intel corp'.format_vendor)
+      assert_equal(VENDOR_MICROSOFT, 'microsoft'.format_vendor)
+      assert_equal(VENDOR_ORACLE, 'oracle'.format_vendor)
+      assert_equal(VENDOR_ORACLE, 'sun'.format_vendor)
+      assert_equal(VENDOR_ORACLE, 'sunw'.format_vendor)
+      assert_equal(VENDOR_ORACLE, 'sun microsystems'.format_vendor)
+      assert_equal(VENDOR_QLOGIC, 'qlogic'.format_vendor)
+      assert_equal(VENDOR_REDHAT, 'redhat'.format_vendor)
+      assert_equal(VENDOR_REDHAT, 'red hat'.format_vendor)
+      assert_equal(VENDOR_SUSE, 'suse linux'.format_vendor)
+      assert_equal(VENDOR_VMWARE, 'vmware'.format_vendor)
+
+      assert_equal('Some other vendor', 'Some other vendor'.format_vendor)
+      assert_equal(nil, ''.format_vendor)
+    end
+
+    should 'return the ip-formatted value from a string of hex values via #hex_to_address' do
+      assert_equal('255.255.255.0', 'ffffff00'.hex_to_address)
+    end
+
+    should 'remove the architecture from a string via #remove_arch' do
+      assert_equal('Microsoft SQL Server 2008', 'Microsoft SQL Server 2008 32 bit'.remove_arch)
+      assert_equal('Microsoft SQL Server 2008', 'Microsoft SQL Server 2008 32-bit'.remove_arch)
+      assert_equal('Microsoft SQL Server 2008', 'Microsoft SQL Server 2008 (32-bit)'.remove_arch)
+      assert_equal('Microsoft SQL Server 2008', 'Microsoft SQL Server 2008 (64-bit)'.remove_arch)
+      assert_equal('Microsoft SQL Server 2008', 'Microsoft SQL Server 2008'.remove_arch)
+
+      test_string = 'Microsoft SQL Server 2008 32 bit'
+      test_string.remove_arch!
+      assert_equal('Microsoft SQL Server 2008', test_string)
+    end
+
+    should 'remove unnecessary characters from a string via #string_clean' do
+      assert_equal('this has an invalid character', "this has an invalid\u00A0 character".string_clean)
+      assert_equal('this should be stripped', ' this should be stripped '.string_clean)
+      assert_equal('this should be stripped', ' this should be stripped '.string_clean)
+      assert_equal('registered', 'registered(r)'.string_clean)
+    end
+
+    should 'return the value(s) found between at least one pair of single or double quotes via #within_quotes' do
+      assert_equal(['C'], 'AB"C"'.within_quotes)
+      assert_equal(['A', 'C'], '"A" B "C"'.within_quotes)
+      assert_equal(['A', 'C'], "'A' B 'C'".within_quotes)
+      assert_equal(nil, 'ABC'.within_quotes)
+    end
+  end
+end

data/test/profile_tests/test_core_skeleton

@@ -0,0 +1,107 @@
+require 'setup_tests'
+
+class WindowsCoreTest < Test::Unit::TestCase
+  context 'a Windows target' do
+    setup do
+      @target_name = '0.0.0.0'
+      @target = Target.new(@target_name)
+      @connector = @target.connector = instance_of(WMIConnector)
+
+      @target.detect_profile
+    end
+
+    should 'detect when a target should use the Win2008 profile' do
+      assert_equal(Profiles::Win2008, @target.target_profile)
+    end
+
+    context 'being scanned' do
+      setup do
+      end
+
+      context 'for file system information' do
+        setup do
+        end
+
+        should 'return file system information via #get_file_systems' do
+        end
+      end
+
+      context 'for hardware information' do
+        setup do
+        end
+
+        should 'return hardware information via #get_hardware' do
+        end
+      end
+
+      context 'for hosted shares' do
+        setup do
+        end
+
+        should 'return hosted share information via #get_hosted_shares' do
+        end
+      end
+
+      context 'for installed applications' do
+        setup do
+        end
+
+        should 'return installed applications via #get_installed_applications' do
+        end
+      end
+
+      context 'for installed patches' do
+        should 'parse out the patches from the registry location for applications' do
+        end
+      end
+
+      context 'for installed services' do
+        setup do
+        end
+
+        should 'return service information via #get_installed_services' do
+        end
+      end
+
+      context 'for local users and groups' do
+        should 'allow us to detect the user name of an account from its guid via #get_username' do
+        end
+
+        should 'return local user groups and accounts via #get_local_user_groups if the server is not a domain controller' do
+        end
+      end
+      
+      context 'for network identification' do
+        setup do
+        end
+
+        should 'return the network identification via #get_network_id' do
+        end
+      end
+
+      context 'for network interfaces' do
+        setup do
+        end
+
+        should 'return ethernet interface information via #get_network_interfaces' do
+        end
+
+        should 'return fibre channel interface information via #get_network_interfaces' do
+        end
+      end
+
+      context 'for operating system information' do
+        setup do
+        end
+
+        should 'return operating system information via #get_operating_system' do
+        end
+      end
+
+      context 'for system roles' do
+        should 'return a list of system roles via #get_system_roles' do
+        end
+      end
+    end
+  end
+end