1 files changed, 49 insertions, 49 deletions

diff --git a/spec/functional/wmi_spec.rb b/spec/functional/wmi_spec.rb
index cf16f44..e6bfe0e 100644
--- a/spec/functional/wmi_spec.rb
+++ b/spec/functional/wmi_spec.rb
@@ -16,101 +16,101 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe WmiLite::Wmi, :windows_only do
   let(:wmi) { WmiLite::Wmi.new(namespace) }
 
   def validate_wmi_results(results, class_name)
     result_collection = cardinality_transform.call(results)
-    result_collection.each do | result |
+    result_collection.each do |result|
       # make sure the class name of the instance is what we asked for
-      expect(result['creationclassname'].downcase).to eql(class_name.downcase)
+      expect(result["creationclassname"].downcase).to eql(class_name.downcase)
     end
   end
 
-  shared_examples_for 'a valid WMI query result' do
-    it 'should successfully return multiple results' do
+  shared_examples_for "a valid WMI query result" do
+    it "should successfully return multiple results" do
       query_parameter = wmi_query.nil? ? wmi_class : wmi_query
       results = wmi.send(query_method, query_parameter)
       validate_wmi_results(results, wmi_class)
     end
 
-    describe 'when the namespace is invalid' do
-      it_behaves_like 'an invalid namespace'
+    describe "when the namespace is invalid" do
+      it_behaves_like "an invalid namespace"
     end
   end
 
-  shared_examples_for 'an invalid query' do
-    it 'should raise an exception' do
+  shared_examples_for "an invalid query" do
+    it "should raise an exception" do
       expect { wmi.send(query_method, wmi_query) }.to raise_error(WmiLite::WmiException)
     end
   end
 
-  shared_examples_for 'an invalid namespace' do
-    it 'should raise an exception if an invalid namespace is specified' do
-      invalid_wmi = WmiLite::Wmi.new('root/notvalid')
+  shared_examples_for "an invalid namespace" do
+    it "should raise an exception if an invalid namespace is specified" do
+      invalid_wmi = WmiLite::Wmi.new("root/notvalid")
       expect { invalid_wmi.send(query_method, wmi_query) }.to raise_error(WmiLite::WmiException)
     end
   end
 
-  shared_examples_for 'a valid WMI query' do
-    let(:wmi_class) { 'Win32_LogicalDisk' }
-    it_behaves_like 'a valid WMI query result'
+  shared_examples_for "a valid WMI query" do
+    let(:wmi_class) { "Win32_LogicalDisk" }
+    it_behaves_like "a valid WMI query result"
 
-    let(:wmi_class) { 'Win32_ComputerSystem' }
-    it_behaves_like 'a valid WMI query result'
+    let(:wmi_class) { "Win32_ComputerSystem" }
+    it_behaves_like "a valid WMI query result"
 
-    let(:wmi_class) { 'Win32_Process' }
-    it_behaves_like 'a valid WMI query result'
+    let(:wmi_class) { "Win32_Process" }
+    it_behaves_like "a valid WMI query result"
 
-    context 'that return 0 results' do
-      let(:wmi_class) { 'Win32_TapeDrive' }
-      it_behaves_like 'a valid WMI query result'
+    context "that return 0 results" do
+      let(:wmi_class) { "Win32_TapeDrive" }
+      it_behaves_like "a valid WMI query result"
     end
   end
 
-  context 'when making valid queries' do
+  context "when making valid queries" do
     let(:namespace) { nil }
     let(:wmi_query) { nil }
-    let(:cardinality_transform) { lambda{|x| x} }
-    context 'using first_of' do
-      let(:cardinality_transform) { lambda{|x| x.nil? ? [] : [x] } }
+    let(:cardinality_transform) { lambda { |x| x } }
+    context "using first_of" do
+      let(:cardinality_transform) { lambda { |x| x.nil? ? [] : [x] } }
       let(:query_method) { :first_of }
-      it_behaves_like 'a valid WMI query'
+      it_behaves_like "a valid WMI query"
     end
 
-    context 'using instances_of' do
+    context "using instances_of" do
       let(:query_method) { :instances_of }
-      it_behaves_like 'a valid WMI query'
+      it_behaves_like "a valid WMI query"
     end
 
-    context 'using query' do
+    context "using query" do
       let(:wmi_query) { "select * from #{wmi_class}" }
       let(:query_method) { :query }
-      it_behaves_like 'a valid WMI query'
+      it_behaves_like "a valid WMI query"
     end
   end
 
-  context 'when making invalid queries' do
+  context "when making invalid queries" do
     let(:namespace) { nil }
 
-    let(:wmi_query) { 'invalidclass' }
+    let(:wmi_query) { "invalidclass" }
     let(:query_method) { :first_of }
-    it_behaves_like 'an invalid query'
+    it_behaves_like "an invalid query"
 
     let(:query_method) { :instances_of }
-    it_behaves_like 'an invalid query'
+    it_behaves_like "an invalid query"
 
     let(:query_method) { :query }
-    let(:wmi_query) { 'nosql_4_life' }
-    it_behaves_like 'an invalid query'
+    let(:wmi_query) { "nosql_4_life" }
+    it_behaves_like "an invalid query"
   end
 
   let(:namespace) { nil }
-  describe 'when querying Win32_Environment' do
-    it 'should have the same environment variables as the Ruby ENV environment hash' do
-      results = wmi.instances_of('Win32_Environment')
+  describe "when querying Win32_Environment" do
+    it "should have the same environment variables as the Ruby ENV environment hash" do
+      results = wmi.instances_of("Win32_Environment")
 
       variables = {}
 
@@ -119,15 +119,15 @@ describe WmiLite::Wmi, :windows_only do
       # PROCESSOR_ARCHITECTURE is actually the real processor arch of the system, so #{ENV['processor_architecture']} will
       # report X86, while WMI will (correctly) report X64.
       # And username is oddly the username of the WMI service, i.e. 'SYSTEM'.
-      ignore = {'path' => true, 'pathext' => true, 'processor_architecture' => true, 'psmodulepath' => true, 'username' => true}
-      results.each do | result |
-        if ! variables.has_key?(result['name']) || result['username'] != '<SYSTEM>'
-          variables[result['name']] = result['variablevalue']
+      ignore = { "path" => true, "pathext" => true, "processor_architecture" => true, "psmodulepath" => true, "username" => true }
+      results.each do |result|
+        if ! variables.key?(result["name"]) || result["username"] != "<SYSTEM>"
+          variables[result["name"]] = result["variablevalue"]
         end
       end
 
       verified_count = 0
-      variables.each_pair do | name, value |
+      variables.each_pair do |name, value|
         if ignore[name.downcase] != true
 
           # Turn %SYSTEMROOT% into c:\windows
@@ -146,10 +146,10 @@ describe WmiLite::Wmi, :windows_only do
   end
 
   let(:namespace) { nil }
-  it 'should ignore case when retrieving WMI properties' do
-    result = wmi.first_of('Win32_ComputerSystem')
-    caption_mixed = result['Caption']
-    caption_lower = result['caption']
+  it "should ignore case when retrieving WMI properties" do
+    result = wmi.first_of("Win32_ComputerSystem")
+    caption_mixed = result["Caption"]
+    caption_lower = result["caption"]
 
     expect(caption_mixed.nil?).to eql(false)
     expect(caption_lower.nil?).to eql(false)