boris 1.0.0.beta.1

data/test/profile_tests/test_unix_core.rb

@@ -0,0 +1,117 @@
+require 'setup_tests'
+
+class UNIXCoreTest < ProfileTestSetup
+  context 'a UNIX target' do
+    setup do
+      @connector = @target.connector = instance_of(SSHConnector)
+      @target.stubs(:target_profile).returns(Profiles::UNIX)
+      @target.extend(Profiles::UNIX)
+      @connector.stubs(:value_at).with('uname -a').returns('some_flavor_of_unix')
+    end
+
+    context 'being scanned' do
+      setup do
+      end
+
+      context 'for file system information' do
+        setup do
+          @file_system_data = [
+            '/dev/md/dsk/d10|1000|500|/',
+            '/dev/md/dsk/d11|2000|1000|/var'
+          ]
+
+          @expected_data = [
+            {
+              :capacity_mb=>1000,
+              :file_system=>'/dev/md/dsk/d10',
+              :mount_point=>'/',
+              :san_storage=>nil,
+              :used_space_mb=>500
+            },
+            {
+              :capacity_mb=>2000,
+              :file_system=>'/dev/md/dsk/d11',
+              :mount_point=>'/var',
+              :san_storage=>nil,
+              :used_space_mb=>1000
+            }
+          ]
+        end
+
+        should 'return file system information via #get_file_systems' do
+          file_system_command = %q{df -kl 2>/dev/null | grep ^/ | nawk '{print $1 "|" $2 / 1024 "|" $3 / 1024 "|" $6}'}
+
+          @connector.stubs(:values_at).with(file_system_command).returns(@file_system_data)
+
+          @target.get_file_systems
+
+          assert_equal(@expected_data, @target.file_systems)
+        end
+      end
+
+      # OS SPECIFIC
+      #context 'for hardware information' do
+      #end
+
+      # OS SPECIFIC
+      #context 'for hosted shares' do
+      #end
+
+      # OS SPECIFIC
+      #context 'for installed applications' do
+      #end
+
+      # OS SPECIFIC
+      #context 'for installed patches' do
+      #end
+
+      # OS SPECIFIC
+      #context 'for installed services' do
+      #end
+
+      context 'for local users and groups' do
+        setup do
+          @user_data = [
+            'root:x:0:0:Super-User:/root:/sbin/sh',
+            'usera:x:2001:10:User A:/export/home/usera:/bin/ksh',
+            'userb:x:2001:10:User B:/export/home/userb:/bin/ksh'
+          ]
+          @group_data = ['root::0:', 'staff::10:']
+          @expected_data = [{:members=>['root'], :name=>'root'}, {:members=>['usera', 'userb'], :name=>'staff'}]
+        end
+
+        should 'return local user groups and accounts via #get_local_user_groups' do
+          @connector.stubs(:values_at).with('cat /etc/passwd | grep -v "^#"').returns(@user_data)
+          @connector.stubs(:values_at).with('cat /etc/group | grep -v "^#"').returns(@group_data)
+
+          @target.get_local_user_groups
+
+          assert_equal(@expected_data, @target.local_user_groups)
+        end
+      end
+
+      context 'for network identification' do
+        setup do
+          @expected_data = {:domain=>'mydomain.com', :hostname=>'SERVER01'}
+        end
+
+        should 'return the domain and hostname via #get_network_id' do
+          @connector.stubs(:value_at).with('hostname').returns(@expected_data[:hostname])
+          @connector.stubs(:value_at).with('domainname').returns(@expected_data[:domain])
+
+          @target.get_network_id
+
+          assert_equal(@expected_data, @target.network_id)
+        end
+      end
+
+      # OS SPECIFIC
+      #context 'for network interfaces' do; end
+      #end
+
+      # OS SPECIFIC
+      #context 'for operating system information' do
+      #end
+    end
+  end
+end

data/test/profile_tests/test_windows.rb

@@ -0,0 +1,536 @@
+require 'setup_tests'
+
+class WindowsCoreTest < ProfileTestSetup
+  extend Profiles::Structure
+
+  context 'a Windows target' do
+    setup do
+      @connector = @target.connector = instance_of(WMIConnector)
+      @target.stubs(:target_profile).returns(Profiles::Windows)
+      @target.extend(Profiles::Windows)
+      @connector.stubs(:value_at).with('SELECT Name FROM Win32_OperatingSystem').returns({:name=>'Windows Server 2008'})
+    end
+
+    context 'being scanned' do
+      setup do
+      end
+
+      context 'for file system information' do
+        setup do
+          @logical_disks_qry = 'SELECT FreeSpace, Name, Size FROM Win32_LogicalDisk WHERE DriveType=3'
+          @logical_disks_data = [
+            {:freespace=>1024, :name=>'C:', :size=>2048}
+          ]
+
+          @physical_disks_qry = 'SELECT DeviceID, Model FROM Win32_DiskDrive'
+          @physical_disks_data = [
+            {
+              :deviceid=>'\\.\PHYSICALDRIVE0',
+              :model=>'LOGICAL VOLUME SCSI Disk Device'
+            }
+          ]
+
+          @partition_mapping_qry = 'SELECT Antecedent, Dependent FROM Win32_LogicalDiskToPartition'
+          @partition_mapping_data = [
+            {
+              :antecedent=>"\\#{@target_name}\\root\\cimv2:Win32_DiskPartition.DeviceID=\"Disk #0, Partition #0\"",
+              :dependent=>"\\#{@target_name}\\root\\cimv2:Win32_LogicalDisk.DeviceID=\"C:\""
+            }
+          ]
+
+          @disk_partitions_qry = "SELECT Antecedent, Dependent FROM Win32_DiskDriveToDiskPartition"
+          @disk_partitions_data = [
+            {
+              :antecedent=>"\\#{@target_name}\\root\\cimv2:Win32_DiskDrive.DeviceID=\"\\\\.\\PHYSICALDRIVE0\"",
+              :dependent=>"\\#{@target_name}\\root\\cimv2:Win32_DiskPartition.DeviceID=\"Disk #0, Partition #0\""
+            }
+          ]
+
+          @expected_data = [
+            {
+              :capacity_mb=>2,
+              :file_system=>'Disk #0, Partition #0',
+              :mount_point=>'C:',
+              :san_storage=>nil,
+              :used_space_mb=>1
+            }
+          ]
+        end
+
+        should 'return file system information via #get_file_systems' do
+          @connector.stubs(:values_at).with(@logical_disks_qry).returns(@logical_disks_data)
+          @connector.stubs(:values_at).with(@partition_mapping_qry).returns(@partition_mapping_data)
+          @connector.stubs(:values_at).with(@physical_disks_qry).returns(@physical_disks_data)
+          @connector.stubs(:values_at).with(@disk_partitions_qry).returns(@disk_partitions_data)
+
+          @target.get_file_systems
+
+          assert_equal(@expected_data, @target.file_systems)
+        end
+      end
+
+      context 'for hardware information' do
+        setup do
+          @bios_qry = 'SELECT SerialNumber, SMBIOSBIOSVersion FROM Win32_BIOS'
+          @bios_data = {:serialnumber=>'1234ABCD', :smbiosbiosversion=>'6.0'}
+
+          @model_qry = 'SELECT Manufacturer, Model, TotalPhysicalMemory FROM Win32_ComputerSystem'
+          @model_data = {
+            :manufacturer=>'VMware, Inc.',
+            :model=>'VMware Virtual Platform',
+            :totalphysicalmemory=>2146861056
+          }
+          
+          @cpu_qry = 'SELECT * FROM Win32_Processor'
+          @cpu_data = [
+            {
+              :datawidth=>32,
+              :l2cachesize=>1024,
+              :manufacturer=>'AuthenticAMD',
+              :maxclockspeed=>2813,
+              :name=>'Dual-Core AMD Opteron(tm) Processor 8220',
+              :numberofcores=>1,
+              :numberoflogicalprocessors=>1
+            }
+          ]
+
+          @expected_data = {
+            :cpu_architecture=>32,
+            :cpu_core_count=>1,
+            :cpu_model=>'Dual-Core AMD Opteron(tm) Processor 8220',
+            :cpu_physical_count=>1,
+            :cpu_speed_mhz=>2813,
+            :cpu_vendor=>'AuthenticAMD',
+            :firmware_version=>'6.0',
+            :model=>'VMware Virtual Platform',
+            :memory_installed_mb=>2047,
+            :serial=>'1234ABCD',
+            :vendor=>'VMware, Inc.'
+          }
+        end
+
+        should 'return hardware information via #get_hardware' do
+          @connector.stubs(:value_at).with(@bios_qry).returns(@bios_data)
+          @connector.stubs(:value_at).with(@model_qry).returns(@model_data)
+          @connector.stubs(:values_at).with(@cpu_qry).returns(@cpu_data)
+
+          @target.get_hardware
+
+          assert_equal(@expected_data, @target.hardware)
+        end
+      end
+
+      context 'for hosted shares' do
+        setup do
+          @expected_data = [{:name=>'myshare', :path=>'D:\myshare'}]
+        end
+
+        should 'return hosted share information via #get_hosted_shares' do
+          @connector.stubs(:values_at).with('SELECT Name, Path FROM Win32_Share WHERE Type = 0').returns(@expected_data)
+          @target.get_hosted_shares
+          assert_equal(@expected_data, @target.hosted_shares)
+        end
+      end
+
+      context 'for installed applications' do
+        setup do
+          @guid = '{4AB6A079-178B-4144-B21F-4D1AE71666A2}'
+          @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]
+          @expected_product_key = 'BBBBB-BBBBB-BBBBB-BBBBB-BBBBB'
+        end
+
+        should 'extract the product key from a binary string' do
+          assert_equal(@expected_product_key, @product_key_binary.to_ms_product_key)
+        end
+
+        context 'by microsoft' do
+          context 'in the sqlserver family' do
+            should 'detect the product key for various sqlserver editions' do
+
+              versions = []
+              versions << {:code=>90, :instance=>'mssql.1', :name=>'Microsoft SQL Server 2005'}
+              versions << {:code=>100, :instance=>'mssql10.1', :name=>'Microsoft SQL Server 2008'}
+              versions << {:code=>110, :instance=>'mssql11.1', :name=>'Microsoft SQL Server 2012'}
+
+              key_path = 'SOFTWARE\Microsoft\Microsoft SQL Server'
+
+              versions.each do |version|
+                @connector.stubs(:registry_subkeys_at).returns(["#{key_path}\\#{version[:instance]}"])
+                @connector.stubs(:registry_values_at).with("#{key_path}\\#{version[:code]}\\ProductID").returns({:digitalproductid=>@product_key_binary})
+                assert_equal(@expected_product_key, @target.get_product_key(version[:name]))
+              end
+            end
+          end
+
+          context 'in the visual studio family' do
+            setup do
+              @connector.stubs(:registry_values_at).at_least_once.returns({:pidkey=>@expected_product_key.gsub(/-/, '')})
+            end
+
+            should 'detect the product key for various Visual Studio editions' do
+              assert_equal(@expected_product_key, @target.get_product_key('Microsoft Visual Studio 2005 Professional Edition'))
+              assert_equal(@expected_product_key, @target.get_product_key('Microsoft Visual Studio 2008 Professional Edition'))
+            end
+          end
+
+          context "in the exchange/office/windows families" do
+            setup do
+              @connector.stubs(:registry_values_at).at_least_once.returns({:digitalproductid=>@product_key_binary})
+            end
+
+            should 'detect the product key for various Exchange editions' do
+              assert_equal(@expected_product_key, @target.get_product_key('Microsoft Exchange'))
+            end
+
+            should 'detect the product key for various Office and Exchange editions' do
+              assert_equal(@expected_product_key, @target.get_product_key('Microsoft Office Professional Edition 2003', @guid))
+              assert_equal(@expected_product_key, @target.get_product_key('Microsoft Office Project Server 12', @guid))
+              assert_equal(@expected_product_key, @target.get_product_key('Microsoft Office SharePoint Server 2007', @guid))
+              assert_equal(@expected_product_key, @target.get_product_key('Microsoft Office XP Professional with FrontPage', @guid))
+            end
+
+            should 'detect the product key for various Windows editions' do
+              assert_equal(@expected_product_key, @target.get_product_key('Microsoft Windows'))
+            end
+          end
+        end
+
+        should 'return installed applications via #get_installed_applications' do
+          key_path = Profiles::Windows::APP64_KEYPATH + '\{4AB6A079-178B-4144-B21F-4D1AE71666A2}'
+
+          application_data = {
+            :installdate=>'20120101',
+            :installlocation=>'',
+            :displayname=>'Microsoft SQL Server 2008 R2 Native Client',
+            :publisher=>'Microsoft Corporation',
+            :displayversion=>'10.50.1600.1'
+          }
+
+          expected_data = {
+            :date_installed=>DateTime.parse(application_data[:installdate]),
+            :install_location=>nil,
+            :license_key=>nil,
+            :name=>application_data[:displayname],
+            :vendor=>application_data[:publisher],
+            :version=>application_data[:displayversion]
+          }
+
+          @connector.stubs(:registry_subkeys_at).with(Profiles::Windows::ORACLE_KEYPATH).returns([])
+
+          @connector.stubs(:registry_subkeys_at).with(Profiles::Windows::APP32_KEYPATH).returns([])
+          @connector.stubs(:registry_subkeys_at).with(Profiles::Windows::APP64_KEYPATH).returns([key_path])
+
+          sql_key_path = 'SOFTWARE\Microsoft\Microsoft SQL Server'
+          @connector.stubs(:registry_subkeys_at).with(sql_key_path).returns(["#{sql_key_path}\\mssql10.1"])
+          @connector.stubs(:registry_values_at).with("#{sql_key_path}\\100\\ProductID").returns({})
+          @connector.stubs(:registry_values_at).with("#{sql_key_path}\\Setup").returns({})
+          @connector.stubs(:registry_values_at).with(key_path).returns(application_data)
+
+          @target.get_installed_applications
+
+          assert_equal([expected_data], @target.installed_applications)
+        end
+      end
+
+      context 'for installed patches' do
+        should 'parse out the patches from the registry location for applications' do
+          wmi_patch_data = {
+            :hotfixid=>'KB456789',
+            :installedby=>'SYSTEM',
+            :installedon=>'1/1/2013',
+            :servicepackineffect=>''
+          }
+
+          registry_patch_data = {
+            :displayname=>'KB123456',
+            :displayversion=>'1.0',
+            :installdate=>'20120101',
+            :installlocation=>'',
+            :publisher=>'Microsoft Corporation'
+          }
+          registry_patch_key_path = "#{Profiles::Windows::APP32_KEYPATH}\\#{registry_patch_data[:displayname]}"
+
+          expected_data = [
+            {:date_installed=>DateTime.parse(wmi_patch_data[:installedon]), :installed_by=>wmi_patch_data[:installedby], :patch_code=>wmi_patch_data[:hotfixid]},
+            {:date_installed=>DateTime.parse(registry_patch_data[:installdate]), :installed_by=>nil, :patch_code=>registry_patch_data[:displayname]}
+          ]
+
+          @connector.stubs(:values_at).returns([wmi_patch_data])
+
+          @connector.stubs(:registry_subkeys_at).with(Profiles::Windows::APP32_KEYPATH).returns([registry_patch_key_path])
+          @connector.stubs(:registry_subkeys_at).with(Profiles::Windows::APP64_KEYPATH).returns([])
+          @connector.stubs(:registry_values_at).with(registry_patch_key_path).returns(registry_patch_data)
+
+          @target.get_installed_patches
+
+          assert_equal(expected_data, @target.installed_patches)
+        end
+      end
+
+      context 'for installed services' do
+        setup do
+          @service_data = [
+            :name=>'Plug and Play',
+            :pathname=>'C:\WINDOWS\system32\services.exe',
+            :startmode=>'Auto'
+          ]
+
+          @expected_data = [{
+            :name=>'Plug and Play',
+            :install_location=>'C:\WINDOWS\system32\services.exe',
+            :start_mode=>'Auto'
+          }]
+        end
+
+        should 'return service information via #get_installed_services' do
+          @connector.stubs(:values_at).with('SELECT Name, PathName, StartMode FROM Win32_Service').returns(@service_data)
+          
+          @target.get_installed_services
+          assert_equal(@expected_data, @target.installed_services)
+        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
+          user_data = {:caption=>'username', :sid=>'S-1-1-1'}
+
+          @connector.stubs(:value_at).with("SELECT Caption, SID FROM Win32_UserAccount WHERE SID = '#{user_data[:sid]}'").returns(user_data)
+
+          assert_equal(user_data[:caption], @target.get_username(user_data[:sid]))
+        end
+
+        should 'return local user groups and accounts via #get_local_user_groups if the server is not a domain controller' do
+          hostname = 'SERVER01'
+          group = 'Users'
+          members = ["#{hostname}\\user1", "#{hostname}\\user2"]
+
+          wmi_member_data = [
+            {:partcomponent=>"\\#{hostname}\root\cimv2:Win32_UserAccount.Domain=\"#{hostname}\",Name=\"user1\""},
+            {:partcomponent=>"\\#{hostname}\root\cimv2:Win32_UserAccount.Domain=\"#{hostname}\",Name=\"user2\""}
+          ]
+          
+          expected_data = [{:name=>group, :members=>members}]
+
+          @target.instance_variable_set(:@network_id, {:domain=>'mydomain.com', :hostname=>hostname})
+          
+          @connector.stubs(:value_at).with('SELECT Roles FROM Win32_ComputerSystem').returns({:roles=>[]})
+
+          @connector.stubs(:values_at).with("SELECT Name FROM Win32_Group WHERE Domain = '#{hostname}'").returns([{:name=>'Users'}])
+          @connector.stubs(:values_at).with("SELECT * FROM Win32_GroupUser WHERE GroupComponent = \"Win32_Group.Domain='#{hostname}',Name='#{group}'\"").returns(wmi_member_data)
+
+          @target.get_local_user_groups
+
+          assert_equal(expected_data, @target.local_user_groups)
+        end
+      end
+
+      context 'for network identification' do
+        setup do
+          @expected_data = {:domain=>'mydomain.com', :name=>'SERVER01'}
+        end
+
+        should 'return the domain and hostname via #get_network_id' do
+          @connector.stubs(:value_at).with('SELECT Domain, Name FROM Win32_ComputerSystem').returns(@expected_data)
+          @target.get_network_id
+
+          assert_equal(@target.network_id[:domain], @expected_data[:domain])
+          assert_equal(@target.network_id[:hostname], @expected_data[:name])
+        end
+      end
+
+      context 'for network interfaces' do
+        setup do
+          @expected_ethernet_data = [@target.network_interface_template.merge({
+            :auto_negotiate=>false,
+            :current_speed_mbps=>1000,
+            :dns_servers=>['192.168.1.100', '192.168.1.101'],
+            :duplex=>'full',
+            :ip_addresses=>[{:ip_address=>'192.168.1.2', :subnet=>'255.255.255.0'}],
+            :is_uplink=>false,
+            :mac_address=>'01:01:01:01:01:01',
+            :model=>'Intel PRO/1000',
+            :model_id=>'0x1234',
+            :mtu=>1400,
+            :name=>'Local Area Connection',
+            :status=>'up',
+            :type=>'ethernet',
+            :vendor=>'Intel Corp.',
+            :vendor_id=>'0x1234'
+          })]
+
+          @expected_fibre_data = @target.network_interface_template.merge({
+            :current_speed_mbps=>4000,
+            :fabric_name=>'00000000aaaaaaaa',
+            :is_uplink=>false,
+            :model=>'QLogic Fibre Channel Adapter',
+            :model_id=>'0x1234',
+            :name=>'fc0',
+            :node_wwn=>'00000000aaaaaaaa',
+            :port_wwn=>'00000000aaaaaaaa',
+            :status=>'up',
+            :type=>'fibre',
+            :vendor=>'QLogic Corp.',
+            :vendor_id=>'0x1234'
+          })
+        end
+
+        should 'return ethernet interface information via #get_network_interfaces' do
+
+          expected_ethernet_data = @expected_ethernet_data[0]
+          
+          @connector.stubs(:values_at).with('SELECT InstanceName, Manufacturer, ModelDescription FROM MSFC_FCAdapterHBAAttributes', :root_wmi).returns([])
+          @connector.stubs(:values_at).with('SELECT Attributes, InstanceName FROM MSFC_FibrePortHBAAttributes', :root_wmi).returns([])
+
+          ethernet_guid = '{1234ABCD}'
+          nic_keypath = Profiles::Windows::NIC_CFG_KEYPATH
+          ethernet_data = [{
+            :index=>1,
+            :macaddress=>expected_ethernet_data[:mac_address],
+            :manufacturer=>expected_ethernet_data[:vendor],
+            :netconnectionid=>expected_ethernet_data[:name],
+            :netconnectionstatus=>2,
+            :productname=>expected_ethernet_data[:model]
+          }]
+
+          @connector.stubs(:values_at).with('SELECT Index, MACAddress, Manufacturer, NetConnectionID, NetConnectionStatus, ProductName FROM Win32_NetworkAdapter WHERE NetConnectionID IS NOT NULL').returns(ethernet_data)
+
+          adapter_config_data = {
+            :dnsserversearchorder=>expected_ethernet_data[:dns_servers],
+            :ipaddress=>expected_ethernet_data[:ip_addresses].collect{|ip| ip[:ip_address]},
+            :ipsubnet=>expected_ethernet_data[:ip_addresses].collect{|ip| ip[:subnet]}[0],
+            :settingid=>ethernet_guid
+          }
+          @connector.stubs(:value_at).with("SELECT DNSServerSearchOrder, IPAddress, IPSubnet, SettingID FROM Win32_NetworkAdapterConfiguration WHERE Index = #{ethernet_data[0][:index]}").returns(adapter_config_data)
+
+          enum_adapter_data = {:devicename=>"\\DEVICE\\#{ethernet_guid}", :instancename=>expected_ethernet_data[:model]}
+
+          nic_cfg_path = nic_keypath + "\\0001"
+
+          @connector.stubs(:registry_values_at).with(nic_cfg_path + '\\Linkage').returns(:export=>[enum_adapter_data[:devicename]])
+          @connector.stubs(:registry_values_at).with(nic_cfg_path).returns({:matchingdeviceid=>'pci\\ven_1234&dev_1234', :speedduplex=>1})
+          @connector.stubs(:registry_subkeys_at).with(nic_cfg_path + "\\Ndi\\params").returns([nic_cfg_path + '\\SpeedDuplex'])
+          @connector.stubs(:registry_values_at).with(nic_cfg_path + "\\Ndi\\params\\speedduplex\\Enum").returns({'1'.to_sym=>'1000Mbps/Full Duplex'})
+
+          @connector.stubs(:value_at).with("SELECT InstanceName FROM MSNdis_EnumerateAdapter WHERE DeviceName = '#{enum_adapter_data[:devicename].gsub(/\\/, '\\\\\\')}'", :root_wmi).returns(enum_adapter_data)
+          linkspeed_data = {:instancename=>expected_ethernet_data[:model], :ndislinkspeed=>10000000}
+          @connector.stubs(:value_at).with("SELECT NdisLinkSpeed FROM MSNdis_LinkSpeed WHERE InstanceName = '#{expected_ethernet_data[:model]}'", :root_wmi).returns(linkspeed_data)
+
+          @connector.stubs(:registry_values_at).with(Profiles::Windows::TCPIP_CFG_KEYPATH + "\\#{ethernet_guid}").returns({:mtu=>1400})
+
+          @target.get_network_interfaces
+          assert_equal(@expected_ethernet_data, @target.network_interfaces)
+        end
+
+        should 'return fibre channel interface information via #get_network_interfaces' do
+          @connector.stubs(:values_at).with('SELECT Index, MACAddress, Manufacturer, NetConnectionID, NetConnectionStatus, ProductName FROM Win32_NetworkAdapter WHERE NetConnectionID IS NOT NULL').returns([])
+
+          hba_data = {
+            :instancename=>'pci\\ven_1234&dev_1234',
+            :manufacturer=>@expected_fibre_data[:vendor],
+            :modeldescription=>@expected_fibre_data[:model]
+          }
+
+          wwn = [0, 0, 0, 0, 170, 170, 170, 170]
+          hba_profile = {
+            :fabricname=>wwn,
+            :instancename=>hba_data[:instancename],
+            :portspeed=>8,
+            :nodewwn=>wwn,
+            :portwwn=>wwn
+          }
+
+          @connector.stubs(:values_at).with('SELECT InstanceName, Manufacturer, ModelDescription FROM MSFC_FCAdapterHBAAttributes', :root_wmi).returns([hba_data])
+
+          @connector.stubs(:values_at).with("SELECT Attributes, InstanceName FROM MSFC_FibrePortHBAAttributes", :root_wmi).returns([hba_profile])
+
+          @target.get_network_interfaces
+
+          assert_equal([@expected_fibre_data], @target.network_interfaces)
+        end
+      end
+
+      context 'for operating system information' do
+        setup do
+          @os_data = {
+            :caption=>'Microsoft(R) Windows(R) Server 2003, Standard Edition',
+            :csdversion=>'Service Pack 2',
+            :installdate=>'20130101000000.000000-000',
+            :othertypedescription=>'R2',
+            :roles=>[],
+            :version=>'5.2.3790'
+          }
+
+          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, 0, 0, 0, 0, 0, 128, 255, 223, 75, 219, 238, 3, 102, 3, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 148, 135, 143, 209]
+
+          @connector.stubs(:value_at).with('SELECT Roles FROM Win32_ComputerSystem').returns(:roles=>[])
+          @connector.stubs(:value_at).with('SELECT Caption, CSDVersion, InstallDate, OtherTypeDescription, Version FROM Win32_OperatingSystem').returns(@os_data)
+          @connector.stubs(:registry_values_at).with('SOFTWARE\Microsoft\Windows NT\CurrentVersion').returns({:digitalproductid=>product_key_binary})
+
+          @expected_data = {
+            :date_installed=>DateTime.parse(@os_data[:installdate]),
+            :features=>[],
+            :kernel=>@os_data[:version],
+            :license_key=>'BBBBB-BBBBB-BBBBB-BBBBB-BBBBB',
+            :name=>'Microsoft Windows',
+            :roles=>@os_data[:roles],
+            :service_pack=>@os_data[:csdversion],
+            :version=>'Server 2003 R2 Standard'
+          }
+        end
+
+        should 'return operating system information via #get_operating_system' do
+          @target.get_operating_system
+          assert_equal(@expected_data, @target.operating_system)
+        end
+
+        context 'of a windows 2008 host' do
+          setup do
+            @target.extend(Profiles::Windows::Windows2008)
+            @features_qry = 'SELECT Name FROM Win32_ServerFeature'
+            @features_data = [{:name=>'File Server'}, {:name=>'Print Server'}]
+            @connector.stubs(:values_at).with(@features_qry).returns(@features_data)
+
+            @expected_data[:features] = @features_data.map{|h| h[:name]}
+          end
+
+          should 'return the enabled OS features of the OS (only for windows 2008)' do
+            @connector.stubs(:values_at).with(@features_qry).returns(@features_data)
+            @target.get_operating_system
+            assert_equal(@expected_data, @target.operating_system)
+          end
+        end
+      end
+
+      # context 'for system roles' do
+      #   should 'return a list of system roles via #get_system_roles' do
+      #     expected_data = [
+      #       'PrimaryDomainController',
+      #       'IIS7',
+      #       'OracleRDMS',
+      #       'TerminalServer',
+      #       'TerminalServicesLicenseServer'
+      #     ]
+
+      #     @connector.stubs(:value_at).with('SELECT Roles FROM Win32_ComputerSystem').returns({:roles=>['Primary_Domain_Controller']})
+      #     @connector.stubs(:registry_values_at).with(Profiles::Windows::IIS_KEYPATH).returns({:majorversion=>7})
+      #     oracle_key = "#{Profiles::Windows::ORACLE_KEYPATH}\\KEY_OracleHome11g"
+      #     @connector.stubs(:registry_subkeys_at).with(Profiles::Windows::ORACLE_KEYPATH).returns([oracle_key])
+      #     @connector.stubs(:registry_values_at).with(oracle_key).returns({:oracle_group_name=>'Oracle - Orahome11g'})
+
+      #     @connector.stubs(:value_at).with('SELECT TerminalServerMode FROM Win32_TerminalServiceSetting').returns({:terminalservermode=>1})
+      #     @connector.stubs(:value_at).with("SELECT * FROM Win32_Service WHERE Caption = 'Terminal Server Licensing'").returns(true)
+
+      #     @target.get_system_roles
+      #   end
+      # end
+    end
+  end
+end