ohai 15.3.1 → 15.6.3

data/spec/unit/plugins/windows/cpu_spec.rb

@@ -1,118 +0,0 @@
-#
-# Author:: Salim Alam (<salam@chef.io>)
-# Copyright:: Copyright (c) 2015 Chef Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-
-shared_examples "a cpu" do |cpu_no|
-  describe "cpu #{cpu_no}" do
-    it "sets physical_id to CPU#{cpu_no}" do
-      expect(@plugin[:cpu][cpu_no.to_s][:physical_id]).to eq("CPU#{cpu_no}")
-    end
-
-    it "sets mhz to 2793" do
-      expect(@plugin[:cpu][cpu_no.to_s][:mhz]).to eq("2793")
-    end
-
-    it "sets vendor_id to GenuineIntel" do
-      expect(@plugin[:cpu][cpu_no.to_s][:vendor_id]).to eq("GenuineIntel")
-    end
-
-    it "sets model_name to Intel(R) Core(TM) i7-4500U CPU @ 1.80GHz" do
-      expect(@plugin[:cpu][cpu_no.to_s][:model_name])
-        .to eq("Intel(R) Core(TM) i7-4500U CPU @ 1.80GHz")
-    end
-
-    it "sets description to Intel64 Family 6 Model 70 Stepping 1" do
-      expect(@plugin[:cpu][cpu_no.to_s][:description])
-        .to eq("Intel64 Family 6 Model 70 Stepping 1")
-    end
-
-    it "sets model to 17921" do
-      expect(@plugin[:cpu][cpu_no.to_s][:model]).to eq("17921")
-    end
-
-    it "sets family to 2" do
-      expect(@plugin[:cpu][cpu_no.to_s][:family]).to eq("2")
-    end
-
-    it "sets stepping to 9" do
-      expect(@plugin[:cpu][cpu_no.to_s][:stepping]).to eq(9)
-    end
-
-    it "sets cache_size to 64 KB" do
-      expect(@plugin[:cpu][cpu_no.to_s][:cache_size]).to eq("64 KB")
-    end
-  end
-end
-
-describe Ohai::System, "Windows cpu plugin" do
-  before do
-    @plugin = get_plugin("cpu")
-    allow(@plugin).to receive(:collect_os).and_return(:windows)
-
-    @double_wmi_instance = instance_double(WmiLite::Wmi)
-
-    @processors = [{ "description" => "Intel64 Family 6 Model 70 Stepping 1",
-                     "name" => "Intel(R) Core(TM) i7-4500U CPU @ 1.80GHz",
-                     "deviceid" => "CPU0",
-                     "family" => 2,
-                     "manufacturer" => "GenuineIntel",
-                     "maxclockspeed" => 2793,
-                     "numberofcores" => 1,
-                     "numberoflogicalprocessors" => 2,
-                     "revision" => 17_921,
-                     "stepping" => 9,
-                     "l2cachesize" => 64 },
-
-                   { "description" => "Intel64 Family 6 Model 70 Stepping 1",
-                     "name" => "Intel(R) Core(TM) i7-4500U CPU @ 1.80GHz",
-                     "deviceid" => "CPU1",
-                     "family" => 2,
-                     "manufacturer" => "GenuineIntel",
-                     "maxclockspeed" => 2793,
-                     "numberofcores" => 1,
-                     "numberoflogicalprocessors" => 2,
-                     "revision" => 17_921,
-                     "stepping" => 9,
-                     "l2cachesize" => 64 }]
-
-    allow(WmiLite::Wmi).to receive(:new).and_return(@double_wmi_instance)
-
-    allow(@double_wmi_instance).to receive(:instances_of)
-      .with("Win32_Processor")
-      .and_return(@processors)
-
-    @plugin.run
-  end
-
-  it "sets total cpu to 2" do
-    expect(@plugin[:cpu][:total]).to eq(4)
-  end
-
-  it "sets real cpu to 2" do
-    expect(@plugin[:cpu][:real]).to eq(2)
-  end
-
-  it "sets 2 distinct cpus numbered 0 and 1" do
-    expect(@plugin[:cpu]).to have_key("0")
-    expect(@plugin[:cpu]).to have_key("1")
-  end
-
-  it_behaves_like "a cpu", 0
-  it_behaves_like "a cpu", 1
-end

data/spec/unit/plugins/windows/filesystem_spec.rb

@@ -1,226 +0,0 @@
-#
-#  Author:: Nimesh Pathi <nimesh.patni@msystechnologies.com>
-#  Copyright:: Copyright (c) 2018 Chef Software, Inc.
-#  License:: Apache License, Version 2.0
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-#
-
-require "spec_helper"
-require "wmi-lite/wmi"
-
-describe Ohai::System, "Windows Filesystem Plugin", :windows_only do
-  let(:plugin) { get_plugin("windows/filesystem") }
-
-  let(:success) { true }
-
-  let(:logical_disks_instances) do
-    [
-      {
-        "caption" => "C:",
-        "deviceid" => "C:",
-        "size" => "10000000",
-        "filesystem" => "NTFS",
-        "freespace" => "100000",
-        "name" => "C:",
-        "volumename " => "",
-      },
-      {
-        "caption" => "D:",
-        "deviceid" => "D:",
-        "size" => "10000000",
-        "filesystem" => "FAT32",
-        "freespace" => "100000",
-        "name" => "D:",
-        # Lets not pass "volumename" for this drive
-      },
-    ]
-  end
-
-  let(:encryptable_volume_instances) do
-    [
-      {
-        "conversionstatus" => 0,
-        "driveletter" => "C:",
-      },
-      {
-        "conversionstatus" => 2,
-        "driveletter" => "D:",
-      },
-    ]
-  end
-
-  let(:wmi_exception) do
-    namespace = "Exception while testing"
-    exception = WIN32OLERuntimeError.new(namespace)
-    WmiLite::WmiException.new(exception, :ConnectServer, @namespace)
-  end
-
-  before do
-    allow(plugin).to receive(:collect_os).and_return(:windows)
-  end
-
-  describe "#logical_properties" do
-    let(:disks) { logical_disks_instances }
-    let(:logical_props) { %i{kb_size kb_available kb_used percent_used mount fs_type volume_name} }
-
-    it "Returns a mash" do
-      expect(plugin.logical_properties(disks)).to be_a(Mash)
-    end
-
-    it "Returns an empty mash when blank array is passed" do
-      expect(plugin.logical_properties([])).to be_a(Mash)
-      expect(plugin.logical_properties([])).to be_empty
-    end
-
-    it "Returns properties without values when there is no disk information" do
-      data = plugin.logical_properties([{}])
-      expect(data[nil].symbolize_keys.keys).to eq(logical_props)
-      expect(data[nil]["kb_used"]).to eq(0)
-      expect(data[nil]["fs_type"]).to be_empty
-    end
-
-    it "Refines required logical properties out of given instance" do
-      data = plugin.logical_properties(disks)
-      expect(data["C:"].symbolize_keys.keys).to eq(logical_props)
-      expect(data["D:"].symbolize_keys.keys).to eq(logical_props)
-    end
-
-    it "Calculates logical properties out of given instance" do
-      data = plugin.logical_properties(disks)
-      expect(data["C:"]["kb_used"]).to eq(data["D:"]["kb_used"]).and eq(9900)
-      expect(data["C:"]["percent_used"]).to eq(data["D:"]["percent_used"]).and eq(99)
-      expect(data["C:"]["fs_type"]).to eq("ntfs")
-      expect(data["D:"]["fs_type"]).to eq("fat32")
-    end
-  end
-
-  describe "#logical_info" do
-    it "Returns an empty mash when wmi namespace does not exists" do
-      allow(WmiLite::Wmi).to receive(:new).and_raise(wmi_exception)
-      expect(plugin.logical_info).to be_a(Mash)
-      expect(plugin.logical_info).to be_empty
-    end
-
-    it "Returns an empty mash when Win32_LogicalDisk could not be processed" do
-      allow(WmiLite::Wmi).to receive(:new).and_return(success)
-      allow(success)
-        .to receive(:instances_of)
-        .with("Win32_LogicalDisk")
-        .and_raise(wmi_exception)
-      expect(plugin.logical_info).to be_a(Mash)
-      expect(plugin.logical_info).to be_empty
-    end
-
-    it "Returns a Mash loaded with logical details" do
-      allow(WmiLite::Wmi).to receive(:new).and_return(success)
-      allow(success)
-        .to receive(:instances_of)
-        .with("Win32_LogicalDisk")
-        .and_return(logical_disks_instances)
-      expect(plugin.logical_info).to be_a(Mash)
-      expect(plugin.logical_info).not_to be_empty
-    end
-  end
-
-  describe "#encryption_properties" do
-    let(:disks) { encryptable_volume_instances }
-    let(:encryption_props) { [:encryption_status] }
-
-    it "Returns a mash" do
-      expect(plugin.encryption_properties(disks)).to be_a(Mash)
-    end
-
-    it "Returns an empty mash when blank array is passed" do
-      expect(plugin.encryption_properties([])).to be_a(Mash)
-      expect(plugin.encryption_properties([])).to be_empty
-    end
-
-    it "Returns properties without values when there is no disk information" do
-      data = plugin.encryption_properties([{}])
-      expect(data[nil].symbolize_keys.keys).to eq(encryption_props)
-      expect(data[nil]["encryption_status"]).to be_empty
-    end
-
-    it "Refines required encryption properties out of given instance" do
-      data = plugin.encryption_properties(disks)
-      expect(data["C:"].symbolize_keys.keys).to eq(encryption_props)
-      expect(data["D:"].symbolize_keys.keys).to eq(encryption_props)
-    end
-
-    it "Calculates encryption properties out of given instance" do
-      data = plugin.encryption_properties(disks)
-      expect(data["C:"]["encryption_status"]).to eq("FullyDecrypted")
-      expect(data["D:"]["encryption_status"]).to eq("EncryptionInProgress")
-    end
-  end
-
-  describe "#encryptable_info" do
-    it "Returns an empty mash when wmi namespace does not exists" do
-      allow(WmiLite::Wmi).to receive(:new).and_raise(wmi_exception)
-      expect(plugin.encryptable_info).to be_a(Mash)
-      expect(plugin.encryptable_info).to be_empty
-    end
-
-    it "Returns an empty mash when Win32_EncryptableVolume could not be processed" do
-      allow(WmiLite::Wmi).to receive(:new).and_return(success)
-      allow(success)
-        .to receive(:instances_of)
-        .with("Win32_EncryptableVolume")
-        .and_raise(wmi_exception)
-      expect(plugin.encryptable_info).to be_a(Mash)
-      expect(plugin.encryptable_info).to be_empty
-    end
-
-    it "Returns a Mash loaded with encryption details" do
-      allow(WmiLite::Wmi).to receive(:new).and_return(success)
-      allow(success)
-        .to receive(:instances_of)
-        .with("Win32_EncryptableVolume")
-        .and_return(encryptable_volume_instances)
-      expect(plugin.encryptable_info).to be_a(Mash)
-      expect(plugin.encryptable_info).not_to be_empty
-    end
-  end
-
-  describe "#merge_info" do
-    let(:info1) do
-      { "drive1" => { "x" => 10, "y" => "test1" },
-        "drive2" => { "x" => 20, "z" => "test2" } }
-    end
-    let(:info2) do
-      { "drive1" => { "k" => 10, "l" => "test1" },
-        "drive2" => { "l" => 20, "m" => "test2" } }
-    end
-    let(:info3) { { "drive1" => { "o" => 10, "p" => "test1" } } }
-    let(:info4) { { "drive2" => { "q" => 10, "r" => "test1" } } }
-
-    it "Returns an empty mash when no info is passed" do
-      expect(plugin.merge_info([])).to be_a(Mash)
-      expect(plugin.merge_info([])).to be_empty
-    end
-
-    it "Merges all the various properties of filesystems" do
-      expect(plugin.merge_info([info1, info2, info3, info4]))
-        .to eq("drive1" => { "x" => 10, "y" => "test1", "k" => 10, "l" => "test1", "o" => 10, "p" => "test1" },
-               "drive2" => { "x" => 20, "z" => "test2", "l" => 20, "m" => "test2", "q" => 10, "r" => "test1" })
-    end
-
-    it "Does not affect any core information after processing" do
-      expect(plugin.merge_info([info3, info4])).to eq("drive1" => { "o" => 10, "p" => "test1" },
-                                                      "drive2" => { "q" => 10, "r" => "test1" })
-      expect(info3).to eq("drive1" => { "o" => 10, "p" => "test1" })
-      expect(info4).to eq("drive2" => { "q" => 10, "r" => "test1" })
-    end
-  end
-end

data/spec/unit/plugins/windows/fips_spec.rb

@@ -1,60 +0,0 @@
-#
-# Author:: Matt Wrock (<matt@mattwrock.com>)
-# Copyright:: Copyright (c) 2016-2018 Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "openssl"
-
-describe Ohai::System, "plugin fips" do
-  subject do
-    plugin.run
-    plugin["fips"]["kernel"]["enabled"]
-  end
-
-  let(:enabled) { 0 }
-  let(:plugin) { get_plugin("windows/fips") }
-  let(:openssl_test_mode) { false }
-
-  before do
-    allow(plugin).to receive(:collect_os).and_return(:windows)
-  end
-
-  around do |ex|
-
-    $FIPS_TEST_MODE = openssl_test_mode
-    ex.run
-  ensure
-    $FIPS_TEST_MODE = false
-
-  end
-
-  context "with OpenSSL.fips_mode == false" do
-    before { allow(OpenSSL).to receive(:fips_mode).and_return(false) }
-
-    it "does not set fips plugin" do
-      expect(subject).to be(false)
-    end
-  end
-
-  context "with OpenSSL.fips_mode == true" do
-    before { allow(OpenSSL).to receive(:fips_mode).and_return(true) }
-
-    it "sets fips plugin" do
-      expect(subject).to be(true)
-    end
-  end
-end

data/spec/unit/plugins/windows/kernel_spec.rb

@@ -1,79 +0,0 @@
-#
-# Copyright:: Copyright (c) 2018 Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-
-describe Ohai::System, "Windows kernel plugin", :windows_only do
-  let(:plugin) { get_plugin("kernel") }
-
-  before do
-    require "wmi-lite/wmi"
-
-    # Mock a Win32_OperatingSystem OLE32 WMI object
-    caption = double("WIN32OLE", name: "Caption")
-    version = double("WIN32OLE", name: "Version")
-    build_number = double("WIN32OLE", name: "BuildNumber")
-    csd_version  = double("WIN32OLE", name: "CsdVersion")
-    os_type = double("WIN32OLE", name: "OsType")
-    product_type = double("WIN32OLE", name: "ProductType")
-    operating_system_sku = double("WIN32OLE", name: "OperatingSystemSKU")
-    os_properties = [ caption, version, build_number, csd_version, os_type, product_type, operating_system_sku ]
-
-    os = double( "WIN32OLE",
-      properties_: os_properties)
-
-    allow(os).to receive(:invoke).with(build_number.name).and_return("7601")
-    allow(os).to receive(:invoke).with(csd_version.name).and_return("Service Pack 1")
-    allow(os).to receive(:invoke).with(os_type.name).and_return(18)
-    allow(os).to receive(:invoke).with(caption.name).and_return("Microsoft Windows 7 Ultimate")
-    allow(os).to receive(:invoke).with(version.name).and_return("6.1.7601")
-    allow(os).to receive(:invoke).with(product_type.name).and_return(1)
-    allow(os).to receive(:invoke).with(operating_system_sku.name).and_return(48)
-
-    os_wmi = WmiLite::Wmi::Instance.new(os)
-    expect_any_instance_of(WmiLite::Wmi).to receive(:first_of).with("Win32_OperatingSystem").and_return(os_wmi)
-
-    system_type = double("WIN32OLE", name: "SystemType")
-    pc_system_type = double("WIN32OLE", name: "PCSystemType")
-    free_virtual_memory = double("WIN32OLE", name: "FreeVirtualMemory")
-    cs_properties = [ system_type, pc_system_type, free_virtual_memory]
-
-    cs = double("WIN32OLE",
-      properties_: cs_properties)
-
-    allow(cs).to receive(:invoke).with(system_type.name).and_return("x64-based PC")
-    allow(cs).to receive(:invoke).with(pc_system_type.name).and_return(2)
-    allow(cs).to receive(:invoke).with(free_virtual_memory.name).and_return("Why would you want this data here?")
-
-    cs_wmi = WmiLite::Wmi::Instance.new(cs)
-    expect_any_instance_of(WmiLite::Wmi).to receive(:first_of).with("Win32_ComputerSystem").and_return(cs_wmi)
-
-    plugin.run
-  end
-
-  it "sets the correct system information" do
-    expect(plugin[:kernel][:name]).to eq("Microsoft Windows 7 Ultimate")
-    expect(plugin[:kernel][:release]).to eq("6.1.7601")
-    expect(plugin[:kernel][:version]).to eq("6.1.7601 Service Pack 1 Build 7601")
-    expect(plugin[:kernel][:os]).to eq("WINNT")
-    expect(plugin[:kernel][:machine]).to eq("x86_64")
-    expect(plugin[:kernel][:system_type]).to eq("Mobile")
-    expect(plugin[:kernel][:product_type]).to eq("Workstation")
-    expect(plugin[:kernel][:server_core]).to eq(false)
-    expect(plugin[:kernel]).not_to have_key(:free_virtual_memory)
-  end
-end