Functional tests, raise exceptions on query failures

3 files changed, 267 insertions, 7 deletions

diff --git a/spec/functional/wmi_spec.rb b/spec/functional/wmi_spec.rb
new file mode 100644
index 0000000..5d4ecf7
--- /dev/null
+++ b/spec/functional/wmi_spec.rb
@@ -0,0 +1,148 @@
+#
+# Author:: Adam Edwards (<adamed@getchef.com>)
+#
+# Copyright:: 2014, Chef Software, Inc.
+#
+# 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 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 |
+      # make sure the class name of the instance is what we asked for
+      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
+      query_parameter = wmi_query.nil? ? wmi_class : wmi_query
+      results = wmi.send(query_method, query_parameter)
+      validate_wmi_results(results, wmi_class)
+    end
+  end
+
+  shared_examples_for 'an invalid query' do
+    it 'should raise an exception if an invalid namespace is specified' do
+      expect { invalid_wmi = WmiLite::Wmi.new('root/notvalid') }.to raise_error
+    end
+
+    it 'should raise an exception if an invalid class is specified' do
+      expect { wmi.send(query_method, wmi_query) }.to raise_error
+    end
+  end
+
+  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_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'
+    end
+  end
+
+  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(:query_method) { :first_of } 
+      it_behaves_like 'a valid WMI query'
+    end
+
+    context 'using instances_of' do
+      let(:query_method) { :instances_of } 
+      it_behaves_like 'a valid WMI query'
+    end
+
+    context 'using query' do
+      let(:wmi_query) { "select * from #{wmi_class}" }
+      let(:query_method) { :query } 
+      it_behaves_like 'a valid WMI query'
+    end
+  end
+
+  context 'when making invalid queries' do
+    let(:namespace) { nil }
+    let(:wmi_query) { 'invalidclass' }
+
+    let(:query_method) { :first_of }
+    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')
+
+      variables = {}
+
+      # Skip some environment variables because we can't compare them against what's in ENV.
+      # Path, pathext, psmodulepath are special, they ares "merged" between the user and system value.
+      # 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']
+        end
+      end
+
+      verified_count = 0
+      variables.each_pair do | name, value |
+        if ignore[name.downcase] != true
+
+          # Turn %SYSTEMROOT% into c:\windows
+          # so we can compare with what's in ENV
+          evaluated_value = `echo #{value}`.strip 
+
+          expect(evaluated_value).to eql(`echo #{ENV[name]}`.strip)
+          verified_count += 1
+        end
+      end
+      
+      # There are at least 3 variables we could verify in a default
+      # Windows configuration, make sure we saw some
+      expect(verified_count).to be >= 3
+    end
+  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']
+
+    expect(caption_mixed.nil?).to eql(false) 
+    expect(caption_lower.nil?).to eql(false)
+
+    expect(caption_mixed.length).to be > 0
+    expect(caption_lower.length).to be > 0
+    expect(caption_mixed).to eql(caption_lower)
+  end
+
+end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index b773d8a..ee9e966 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,5 +1,12 @@
 # $:.unshift File.expand_path('../../lib', __FILE__)
 require 'rspec'
-require 'wmi-lite/wmi'
-require 'wmi-lite/wmi_instance'
+require 'wmi-lite'
+
+RSpec.configure do |config|
+  config.include(RSpec::Matchers)
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run :focus => true
+  config.filter_run_excluding :windows_only => true if ! (RUBY_PLATFORM =~ /mswin|mingw32|windows/)
+  config.run_all_when_everything_filtered = true
+end
 
diff --git a/spec/unit/wmi_spec.rb b/spec/unit/wmi_spec.rb
index cc26262..a6fb0b5 100644
--- a/spec/unit/wmi_spec.rb
+++ b/spec/unit/wmi_spec.rb
@@ -41,8 +41,8 @@ describe WmiLite::Wmi do
     if expected_result
       expected.each do | expected_value |
         actual_value = actual[index]
-        expected_value.invoke == actual_value.wmi_ole_object.invoke
-        expected_value.properties_.each do | expected_property |
+        expected_value.wmi_ole_object.invoke == actual_value.wmi_ole_object.invoke
+        expected_value.wmi_ole_object.properties_.each do | expected_property |
           if actual_value[expected_property.name].nil?
             expected_result = false
           end
@@ -76,7 +76,7 @@ describe WmiLite::Wmi do
     expect( result_count ).to eq(0)
   end
 
-  shared_examples_for "the first method" do
+  shared_examples_for "the first_of method" do
 
     let(:wmi_properties1) { { 'cores' => 4, 'name' => 'mycomputer1', 'diskspace' => 400, 'os' => 'windows' } }
     let(:wmi_properties2) { { 'cores' => 2, 'name' => 'mycomputer2', 'bios' => 'ami', 'os' => 'windows' } }
@@ -94,11 +94,116 @@ describe WmiLite::Wmi do
       it "should get one instance" do
         results = wmi.first_of('vm')
         expected_result = WmiLite::Wmi::Instance.new(native_query_result.first)
-        is_expected = validate_query_result([results], [expected_result.wmi_ole_object])
+        is_expected = validate_query_result([results], [expected_result])
         expect(is_expected).to eq(true)
       end
     end
+
+    context "when returning more than one instance in the query" do
+      let(:wmi_query_result) { wmi_query_result2 }
+      let(:native_query_result) { native_query_result2 }
+
+      it "should get one instance" do
+        results = wmi.first_of('vm')
+        expected_result = WmiLite::Wmi::Instance.new(native_query_result.first)
+        is_expected = validate_query_result([results], [expected_result])
+        expect(is_expected).to eq(true)
+      end
+    end
+
   end
 
-  it_should_behave_like "the first method"
+  shared_examples_for "the instances_of method" do
+
+    let(:wmi_properties1) { { 'cores' => 4, 'name' => 'mycomputer1', 'diskspace' => 400, 'os' => 'windows' } }
+    let(:wmi_properties2) { { 'cores' => 2, 'name' => 'mycomputer2', 'bios' => 'ami', 'os' => 'windows' } }
+    let(:native_query_result) { [].to_enum }
+
+    it "should not fail with empty query results" do
+      results = wmi.instances_of('vm')
+      expect( results ).to eq([])
+    end
+
+    context "when returning one instance in the query" do
+      let(:wmi_query_result) { wmi_query_result1 }
+      let(:native_query_result) { native_query_result1 }
+
+      it "should get one instance" do
+        results = wmi.instances_of('vm')
+        index = 0
+        expected_result = results.map do | result |
+          WmiLite::Wmi::Instance.new(result.wmi_ole_object)
+        end
+        is_expected = validate_query_result(results, expected_result)
+        expect(is_expected).to eq(true)
+      end
+    end
+
+    context "when returning one instance in the query" do
+      let(:wmi_query_result) { wmi_query_result2 }
+      let(:native_query_result) { native_query_result2 }
+
+      it "should get one instance" do
+        results = wmi.instances_of('vm')
+        index = 0
+        expected_result = results.map do | result |
+          WmiLite::Wmi::Instance.new(result.wmi_ole_object)
+        end
+        is_expected = validate_query_result(results, expected_result)
+        expect(is_expected).to eq(true)
+      end
+    end
+
+  end
+
+  shared_examples_for "the query method" do
+
+    let(:wmi_properties1) { { 'cores' => 4, 'name' => 'mycomputer1', 'diskspace' => 400, 'os' => 'windows' } }
+    let(:wmi_properties2) { { 'cores' => 2, 'name' => 'mycomputer2', 'bios' => 'ami', 'os' => 'windows' } }
+    let(:native_query_result) { [].to_enum }
+
+    it "should not fail with empty query results" do
+      results = wmi.query('vm')
+      expect( results ).to eq([])
+    end
+
+    context "when returning one instance in the query" do
+      let(:wmi_query_result) { wmi_query_result1 }
+      let(:native_query_result) { native_query_result1 }
+
+      it "should get one instance" do
+        results = wmi.query('vm')
+        index = 0
+        expected_result = results.map do | result |
+          WmiLite::Wmi::Instance.new(result.wmi_ole_object)
+        end
+        is_expected = validate_query_result(results, expected_result)
+        expect(is_expected).to eq(true)
+      end
+    end
+
+    context "when returning one instance in the query" do
+      let(:wmi_query_result) { wmi_query_result2 }
+      let(:native_query_result) { native_query_result2 }
+
+      it "should get one instance" do
+        results = wmi.query('vm')
+        index = 0
+        expected_result = results.map do | result |
+          WmiLite::Wmi::Instance.new(result.wmi_ole_object)
+        end
+        is_expected = validate_query_result(results, expected_result)
+        expect(is_expected).to eq(true)
+      end
+    end
+
+  end
+
+
+  it_should_behave_like "the first_of method"
+
+  it_should_behave_like "the instances_of method"
+
+  it_should_behave_like "the query method"
+
 end