boris 1.0.0.beta.1 → 1.0.1

data/test/profile_tests/test_unix_core.rb

@@ -1,117 +0,0 @@
-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

@@ -1,536 +0,0 @@
-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