ohai 14.4.2 → 14.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa2998db0ed97fe69f873899ea65c666badc17e7365c34592f539ee628299d7e
-  data.tar.gz: 26d01af9bf5ba6d2e874ed050b4a54ae167d4d7fcfeb5262eb6a9fa8438cff9a
+  metadata.gz: a51cf17407e9d91624a5fa169e8057d15a75eac70805fc38a4fcbf928141121b
+  data.tar.gz: 69c101063af73a9b0aba3f0956e57ce9c488607e76f605d1425e0d40951bcb38
 SHA512:
-  metadata.gz: 6b9c7a7d84321fcc138c270d6bc06055d2bc3f2cbb49043e1462261d9fe44a5c07049d0bc2c304d47808d383b99ae78c21b01ab2b8a34ad6094678d9cd0e2ebd
-  data.tar.gz: 3eef3a40fbae42dd73cde34434ecfaef6798873655a228465d86c6ec98c1607feb58baea8f7b16037ae7a04100b9b374cb0d58a4bc52bdf4f1bff8ff4937dbbe
+  metadata.gz: 354f6a0bd33873e3d8b124eeb23bfd111bd8b6cf46642fd119c3dd5cfd82666629ccff70fad44b08ac4a7fb2900a566cc0639558b0b5b2d10b95cec4d2e5a052
+  data.tar.gz: 67bdf1bfc49797e0f61d95c96e2ad769c124ea19dc682358ae5fc27042cd8cdc4e08ea3f831a05c5b5edf3e1dd495579e90e9ac1321d7d678db41f58f167b4b9

data/Gemfile

@@ -17,6 +17,19 @@ group :ci do
   gem "rspec_junit_formatter"
 end
 
+group :docs do
+  gem "yard"
+  gem "redcarpet"
+  gem "github-markup"
+end
+
+group :debug do
+  gem "pry"
+  gem "pry-byebug"
+  gem "pry-stack_explorer"
+  gem "rb-readline"
+end
+
 instance_eval(ENV["GEMFILE_MOD"]) if ENV["GEMFILE_MOD"]
 
 # If you want to load debugging tools into the bundle exec sandbox,

data/README.md

@@ -11,7 +11,7 @@ Ohai will print out a JSON data blob for all the known data about your system. W
 Chef distributes ohai as a RubyGem. This README is for developers who want to modify the Ohai source code. For users who want to write plugins for Ohai, see the docs:
 
 - General documentation: <https://docs.chef.io/ohai.html>
-- Custom plugin documentation: <https://docs.chef.io/ohai_custom.html>
+- Writing Ohai Plugins documentation: <https://docs.chef.io/ohai_custom.html>
 
 ## Development Environment:
 
@@ -37,11 +37,16 @@ Ohai has some Rake tasks for doing various things.
 
 ```
 rake -T
-rake build          # Build the gem file ohai-$VERSION.gem
-rake install        # install the gem locally
-rake install:local  # install the gem locally without network access
-rake release        # Create tag $VERSION, build gem, and push to Rubygems
-rake spec           # Run RSpec tests
+rake build               # Build ohai-$VERSION.gem into the pkg directory
+rake clean               # Remove any temporary products
+rake clobber             # Remove any generated files
+rake docs                # Generate YARD Documentation
+rake install             # Build and install ohai-$VERSION.gem into system gems
+rake install:local       # Build and install ohai-$VERSION.gem into system gems without network access
+rake release[remote]     # Create tag $VERSION and build and push ohai-$VERSION.gem to rubygems.org
+rake spec                # Run RSpec code examples
+rake style               # Run Chefstyle tests
+rake style:auto_correct  # Auto-correct RuboCop offenses
 
 ($VERSION is the current version, from the GemSpec in Rakefile)
 ```
@@ -65,7 +70,7 @@ For information on contributing to this project see <https://github.com/chef/che
 Ohai - system information application
 
 - Author:: Adam Jacob ([adam@chef.io](mailto:adam@chef.io))
-- Copyright:: Copyright (c) 2008-2016 Chef Software, Inc.
+- Copyright:: Copyright (c) 2008-2018 Chef Software, Inc.
 - License:: Apache License, Version 2.0
 
 ```text

data/Rakefile

@@ -1,6 +1,4 @@
 require "bundler/gem_tasks"
-require "date"
-require "ohai/version"
 
 begin
   require "rspec/core/rake_task"
@@ -11,14 +9,34 @@ begin
 rescue LoadError
   desc "rspec is not installed, this task is disabled"
   task :spec do
-    abort "rspec is not installed. `(sudo) gem install rspec` to run unit tests"
+    abort "rspec is not installed. bundle install first to make sure all dependencies are installed."
   end
 end
 
-task default: :spec
+begin
+  require "chefstyle"
+  require "rubocop/rake_task"
+  desc "Run Chefstyle tests"
+  RuboCop::RakeTask.new(:style) do |task|
+    task.options += ["--display-cop-names", "--no-color"]
+  end
+rescue LoadError
+  puts "chefstyle gem is not installed. bundle install first to make sure all dependencies are installed."
+end
 
-require "chefstyle"
-require "rubocop/rake_task"
-RuboCop::RakeTask.new(:style) do |task|
-  task.options += ["--display-cop-names", "--no-color"]
+begin
+  require "yard"
+  YARD::Rake::YardocTask.new(:docs)
+rescue LoadError
+  puts "yard is not available. bundle install first to make sure all dependencies are installed."
+end
+
+task :console do
+  require "irb"
+  require "irb/completion"
+  require "ohai"
+  ARGV.clear
+  IRB.start
 end
+
+task default: [:style, :spec]

data/lib/ohai/application.rb

@@ -69,14 +69,6 @@ class Ohai::Application
     proc: lambda { |v| puts "Ohai: #{::Ohai::VERSION}" },
     exit: 0
 
-  def initialize
-    super
-
-    # Always switch to a readable directory. Keeps subsequent Dir.chdir() {}
-    # from failing due to permissions when launched as a less privileged user.
-    Dir.chdir("/")
-  end
-
   def run
     elapsed = Benchmark.measure do
       configure_ohai
@@ -95,6 +87,10 @@ class Ohai::Application
   end
 
   def run_application
+    # Always switch to a readable directory. Keeps subsequent Dir.chdir() {}
+    # from failing due to permissions when launched as a less privileged user.
+    Dir.chdir("/")
+
     config[:invoked_from_cli] = true
     config[:logger] = Ohai::Log.with_child
     ohai = Ohai::System.new(config)

data/lib/ohai/plugins/openstack.rb

@@ -64,8 +64,10 @@ Ohai.plugin(:Openstack) do
       openstack Mash.new
       openstack[:provider] = openstack_provider
 
+      timeout = Ohai::Config.ohai[:openstack_metadata_timeout] || 2
+
       # fetch the metadata if we can do a simple socket connect first
-      if can_socket_connect?(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80)
+      if can_socket_connect?(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80, timeout)
         fetch_metadata.each do |k, v|
           openstack[k] = v
         end

data/lib/ohai/plugins/root_group.rb

@@ -19,8 +19,19 @@ Ohai.plugin(:RootGroup) do
   provides "root_group"
 
   collect_data(:windows) do
-    require "ohai/util/win32/group_helper"
-    root_group Ohai::Util::Win32::GroupHelper.windows_root_group_name
+    require "wmi-lite/wmi"
+
+    wmi = WmiLite::Wmi.new
+    # Per http://support.microsoft.com/kb/243330 SID: S-1-5-32-544 is the
+    # internal name for the Administrators group, which lets us work
+    # properly in environments with a renamed or localized name for the
+    # Administrators group.
+    # Use LocalAccount=True because otherwise WMI will attempt to include
+    # (unneeded) Active Directory groups by querying AD, which is a performance
+    # and reliability issue since AD might not be reachable.
+    groups = wmi.query("select * from Win32_Group where sid like 'S-1-5-32-544' and LocalAccount=True")
+    windows_root_group_name = groups[0]["name"]
+    root_group windows_root_group_name
   end
 
   collect_data(:default) do

data/lib/ohai/plugins/windows/filesystem.rb

@@ -19,36 +19,129 @@
 Ohai.plugin(:Filesystem) do
   provides "filesystem"
 
-  collect_data(:windows) do
+  # Volume encryption or decryption status
+  #
+  # @see https://docs.microsoft.com/en-us/windows/desktop/SecProv/getconversionstatus-win32-encryptablevolume#parameters
+  #
+  CONVERSION_STATUS = %w{FullyDecrypted FullyEncrypted EncryptionInProgress
+                         DecryptionInProgress EncryptionPaused DecryptionPaused}.freeze
 
-    require "wmi-lite/wmi"
+  # Returns a Mash loaded with logical details
+  #
+  # Uses Win32_LogicalDisk and logical_properties to return encryption details of volumes.
+  #
+  # Returns an empty Mash in case of any WMI exception.
+  #
+  # @see https://docs.microsoft.com/en-us/windows/desktop/CIMWin32Prov/win32-logicaldisk
+  #
+  # @return [Mash]
+  #
+  def logical_info
+    wmi = WmiLite::Wmi.new("Root\\CIMV2")
 
-    fs = Mash.new
-    ld_info = Mash.new
+    # Note: we should really be parsing Win32_Volume and Win32_Mapped drive.
+    disks = wmi.instances_of("Win32_LogicalDisk")
+    logical_properties(disks)
+  rescue WmiLite::WmiException
+    Ohai::Log.debug("Unable to access Win32_LogicalDisk. Skipping logical details")
+    Mash.new
+  end
 
-    wmi = WmiLite::Wmi.new
+  # Returns a Mash loaded with encryption details
+  #
+  # Uses Win32_EncryptableVolume and encryption_properties to return encryption details of volumes.
+  #
+  # Returns an empty Mash in case of any WMI exception.
+  #
+  # @note We are fetching Encryption Status only as of now
+  #
+  # @see https://msdn.microsoft.com/en-us/library/windows/desktop/aa376483(v=vs.85).aspx
+  #
+  # @return [Mash]
+  #
+  def encryptable_info
+    wmi = WmiLite::Wmi.new("Root\\CIMV2\\Security\\MicrosoftVolumeEncryption")
+    disks = wmi.instances_of("Win32_EncryptableVolume")
+    encryption_properties(disks)
+  rescue WmiLite::WmiException
+    Ohai::Log.debug("Unable to access Win32_EncryptableVolume. Skipping encryptable details")
+    Mash.new
+  end
 
-    # Grab filesystem data from WMI
-    # Note: we should really be parsing Win32_Volume and Win32_Mapped drive
-    disks = wmi.instances_of("Win32_LogicalDisk")
+  # Refines and calculates logical properties out of given instances
+  #
+  # @param [WmiLite::Wmi::Instance] disks
+  #
+  # @return [Mash] Each drive containing following properties:
+  #
+  #  * :kb_size (Integer)
+  #  * :kb_available (Integer)
+  #  * :kb_used (Integer)
+  #  * :percent_used (Integer)
+  #  * :mount (String)
+  #  * :fs_type (String)
+  #  * :volume_name (String)
+  #
+  def logical_properties(disks)
+    properties = Mash.new
+    disks.each do |disk|
+      property = Mash.new
+      drive = disk["deviceid"]
+      property[:kb_size] = disk["size"].to_i / 1000
+      property[:kb_available] = disk["freespace"].to_i / 1000
+      property[:kb_used] = property[:kb_size] - property[:kb_available]
+      property[:percent_used] = (property[:kb_size] == 0 ? 0 : (property[:kb_used] * 100 / property[:kb_size]))
+      property[:mount] = disk["name"]
+      property[:fs_type] = disk["filesystem"].to_s.downcase
+      property[:volume_name] = disk["volumename"].to_s.downcase
+      properties[drive] = property
+    end
+    properties
+  end
 
+  # Refines and calculates encryption properties out of given instances
+  #
+  # @param [WmiLite::Wmi::Instance] disks
+  #
+  # @return [Mash] Each drive containing following properties:
+  #
+  #  * :encryption_status (String)
+  #
+  def encryption_properties(disks)
+    properties = Mash.new
     disks.each do |disk|
-      filesystem = disk["deviceid"]
-      fs[filesystem] = Mash.new
-      ld_info[filesystem] = Mash.new
-      disk.wmi_ole_object.properties_.each do |p|
-        ld_info[filesystem][p.name.wmi_underscore.to_sym] = disk[p.name.downcase]
+      drive = disk["driveletter"]
+      property = Mash.new
+      property[:encryption_status] = disk["conversionstatus"] ? CONVERSION_STATUS[disk["conversionstatus"]] : ""
+      properties[drive] = property
+    end
+    properties
+  end
+
+  # Merges all the various properties of filesystems
+  #
+  # @param [Array<Mash>] disks_info
+  #   Array of the Mashes containing disk properties
+  #
+  # @return [Mash]
+  #
+  def merge_info(disks_info)
+    fs = Mash.new
+    disks_info.each do |info|
+      info.each do |disk, data|
+        if fs[disk]
+          fs[disk].merge!(data)
+        else
+          fs[disk] = data.dup
+        end
       end
-      fs[filesystem][:kb_size] = ld_info[filesystem][:size].to_i / 1000
-      fs[filesystem][:kb_available] = ld_info[filesystem][:free_space].to_i / 1000
-      fs[filesystem][:kb_used] = fs[filesystem][:kb_size].to_i - fs[filesystem][:kb_available].to_i
-      fs[filesystem][:percent_used] = (fs[filesystem][:kb_size].to_i != 0 ? fs[filesystem][:kb_used].to_i * 100 / fs[filesystem][:kb_size].to_i : 0)
-      fs[filesystem][:mount] = ld_info[filesystem][:name]
-      fs[filesystem][:fs_type] = ld_info[filesystem][:file_system].downcase unless ld_info[filesystem][:file_system].nil?
-      fs[filesystem][:volume_name] = ld_info[filesystem][:volume_name]
     end
+    fs
+  end
 
-    # Set the filesystem data
-    filesystem fs
+  collect_data(:windows) do
+    require "wmi-lite/wmi"
+    filesystem merge_info([logical_info,
+                           encryptable_info])
   end
 end

data/lib/ohai/util/win32/group_helper.rb

@@ -21,6 +21,7 @@ require "ohai/util/win32"
 module Ohai
   module Util
     class Win32::GroupHelper
+      # @deprecated
 
       # Per http://support.microsoft.com/kb/243330 SID: S-1-5-32-544 is the
       # internal name for the Administrators group, which lets us work
@@ -29,6 +30,8 @@ module Ohai
       BUILTIN_ADMINISTRATORS_SID = "S-1-5-32-544".freeze
 
       def self.windows_root_group_name
+        warn "The 'windows_root_group_name' helper is deprecated and will be removed in Ohai 15. Please update your plugins to remove this helper method."
+
         administrators_sid_result = FFI::MemoryPointer.new(:pointer)
         convert_result = Win32.convert_string_sid_to_sid(BUILTIN_ADMINISTRATORS_SID, administrators_sid_result)
         last_win32_error = Win32.get_last_error

data/lib/ohai/version.rb

@@ -18,5 +18,5 @@
 
 module Ohai
   OHAI_ROOT = File.expand_path(File.dirname(__FILE__))
-  VERSION = "14.4.2".freeze
+  VERSION = "14.5.0".freeze
 end

data/spec/unit/plugins/openstack_spec.rb

@@ -21,6 +21,7 @@ require_relative "../../spec_helper.rb"
 describe Ohai::System, "plugin openstack" do
 
   let(:plugin) { get_plugin("openstack") }
+  let(:default_timeout) { 2 }
 
   before(:each) do
     allow(plugin).to receive(:hint?).with("openstack").and_return(false)
@@ -38,7 +39,7 @@ describe Ohai::System, "plugin openstack" do
     context "and the metadata service is not available" do
       before do
         allow(plugin).to receive(:can_socket_connect?)
-          .with(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80)
+          .with(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80, default_timeout)
           .and_return(false)
         plugin[:dmi] = dmi_data
         plugin.run
@@ -77,7 +78,7 @@ describe Ohai::System, "plugin openstack" do
     it "sets openstack provider attribute to dreamhost" do
       plugin["etc"] = { "passwd" => { "dhc-user" => {} } }
       allow(plugin).to receive(:can_socket_connect?)
-        .with(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80)
+        .with(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80, default_timeout)
         .and_return(false)
       plugin[:dmi] = { system: { all_records: [ { Manufacturer: "OpenStack Foundation" } ] } }
       plugin.run
@@ -89,7 +90,7 @@ describe Ohai::System, "plugin openstack" do
     context "and the metadata service is not available" do
       before do
         allow(plugin).to receive(:can_socket_connect?)
-          .with(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80)
+          .with(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80, default_timeout)
           .and_return(false)
         allow(plugin).to receive(:hint?).with("openstack").and_return(true)
         plugin.run
@@ -102,6 +103,23 @@ describe Ohai::System, "plugin openstack" do
       it "doesn't set metadata attributes" do
         expect(plugin[:openstack][:instance_id]).to be_nil
       end
+      context "when timout was set" do
+        let(:override_timout) { 10 }
+        before do
+          Ohai::Config.ohai[:openstack_metadata_timeout] = override_timout
+        end
+        after do
+          Ohai::Config.ohai[:openstack_metadata_timeout] = nil
+        end
+
+        it "overwrite timout by setting" do
+          allow(plugin).to receive(:can_socket_connect?)
+          .with(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80, override_timout)
+          .and_return(false)
+          allow(plugin).to receive(:hint?).with("openstack").and_return(true)
+          plugin.run
+        end
+      end
     end
 
     context "and the metadata service is available" do
@@ -196,7 +214,7 @@ EOM
       before do
         allow(plugin).to receive(:hint?).with("openstack").and_return(true)
         allow(plugin).to receive(:can_socket_connect?)
-          .with(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80)
+          .with(Ohai::Mixin::Ec2Metadata::EC2_METADATA_ADDR, 80, default_timeout)
           .and_return(true)
 
         allow(Net::HTTP).to receive(:start)

data/spec/unit/plugins/root_group_spec.rb

@@ -17,7 +17,6 @@
 #
 
 require_relative "../../spec_helper.rb"
-require "ohai/util/win32/group_helper"
 
 describe Ohai::System, "root_group" do
   before(:each) do
@@ -78,11 +77,20 @@ describe Ohai::System, "root_group" do
   end
 
   describe "windows platform" do
-    it "should return the group administrators" do
+
+    let(:wmi) { double("wmi", { query: "" }) }
+
+    before(:each) do
+      allow(WmiLite::Wmi).to receive(:new).and_return(wmi)
       allow(@plugin).to receive(:collect_os).and_return(:windows)
-      expect(Ohai::Util::Win32::GroupHelper).to receive(:windows_root_group_name).and_return("administrators")
+    end
+    it "should return the group Administrators" do
+      expect(wmi)
+        .to receive(:query)
+        .with("select * from Win32_Group where sid like 'S-1-5-32-544' and LocalAccount=True")
+        .and_return("Administrators")
+
       @plugin.run
-      expect(@plugin[:root_group]).to eq("administrators")
     end
   end
 end

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

@@ -0,0 +1,226 @@
+#
+#  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_relative "../../../spec_helper.rb"
+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(:each) 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ohai
 version: !ruby/object:Gem::Version
-  version: 14.4.2
+  version: 14.5.0
 platform: ruby
 authors:
 - Adam Jacob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-22 00:00:00.000000000 Z
+date: 2018-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: systemu
@@ -511,6 +511,7 @@ files:
 - spec/unit/plugins/virtualbox_spec.rb
 - spec/unit/plugins/vmware_spec.rb
 - spec/unit/plugins/windows/cpu_spec.rb
+- spec/unit/plugins/windows/filesystem_spec.rb
 - spec/unit/plugins/windows/fips_spec.rb
 - spec/unit/plugins/windows/kernel_spec.rb
 - spec/unit/plugins/windows/memory_spec.rb