5 files changed, 225 insertions, 10 deletions

diff --git a/spec/support/shared/functional/windows_script.rb b/spec/support/shared/functional/windows_script.rb
index fc06fb55d0..f677828167 100644
--- a/spec/support/shared/functional/windows_script.rb
+++ b/spec/support/shared/functional/windows_script.rb
@@ -44,4 +44,122 @@ shared_context Chef::Resource::WindowsScript do
   after(:each) do
     File.delete(script_output_path) if File.exists?(script_output_path)
   end
+
+  let!(:resource) do
+    Chef::Resource::WindowsScript::Batch.new("Batch resource functional test", @run_context)
+  end
+
+  shared_examples_for "a script resource with architecture attribute" do
+    context "with the given architecture attribute value" do
+      let(:resource_architecture) { architecture }
+      let(:expected_architecture) do
+        if architecture
+          expected_architecture = architecture
+        else
+          expected_architecture = :i386
+        end
+      end
+      let(:expected_architecture_output) do
+        expected_architecture == :i386 ? 'X86' : 'AMD64'
+      end
+      let(:guard_script_suffix) do
+        "guard"
+      end
+      let(:guard_script_output_path) do
+        "#{script_output_path}#{guard_script_suffix}"
+      end
+      let(:resource_command) do
+        "#{architecture_command} #{output_command} #{script_output_path}"
+      end
+      let(:resource_guard_command) do
+        "#{architecture_command} #{output_command} #{guard_script_output_path}"
+      end
+
+      before(:each) do
+        resource.code resource_command
+        (resource.architecture architecture) if architecture
+        resource.returns(0)
+      end
+
+      it "should create a process with the expected architecture" do
+        resource.run_action(:run)
+        get_process_architecture.should == expected_architecture_output.downcase
+      end
+
+      it "should execute guards with the same architecture as the resource" do
+        resource.only_if resource_guard_command
+        resource.run_action(:run)
+        get_process_architecture.should == expected_architecture_output.downcase
+        get_guard_process_architecture.should == expected_architecture_output.downcase
+        get_guard_process_architecture.should == get_process_architecture
+      end
+
+      let (:architecture) { :x86_64 }
+      it "should execute a 64-bit guard if the guard's architecture is specified as 64-bit" do
+        resource.only_if resource_guard_command, :architecture => :x86_64
+        resource.run_action(:run)
+        get_guard_process_architecture.should == 'amd64'
+      end
+
+      let (:architecture) { :i386 }
+      it "should execute a 32-bit guard if the guard's architecture is specified as 32-bit" do
+        resource.only_if resource_guard_command, :architecture => :i386
+        resource.run_action(:run)
+        get_guard_process_architecture.should == 'x86'
+      end
+    end
+  end
+
+  shared_examples_for "a Windows script running on Windows" do
+
+    describe "when the run action is invoked on Windows" do
+      it "executes the script code" do
+        resource.code("@whoami > #{script_output_path}")
+        resource.returns(0)
+        resource.run_action(:run)
+      end
+    end
+
+    context "when evaluating guards" do
+      it "has a guard_interpreter attribute set to the short name of the resource" do
+        resource.guard_interpreter.should == resource.resource_name
+        resource.not_if "findstr.exe /thiscommandhasnonzeroexitstatus"
+        expect(Chef::Resource).to receive(:resource_for_node).and_call_original
+        expect(resource.class).to receive(:new).and_call_original
+        resource.should_skip?(:run).should be_false
+      end
+    end
+
+    context "when the architecture attribute is not set" do
+      let(:architecture) { nil }
+      it_behaves_like "a script resource with architecture attribute"
+    end
+
+    context "when the architecture attribute is :i386" do
+      let(:architecture) { :i386 }
+      it_behaves_like "a script resource with architecture attribute"
+    end
+
+    context "when the architecture attribute is :x86_64" do
+      let(:architecture) { :x86_64 }
+      it_behaves_like "a script resource with architecture attribute"
+    end
+  end
+
+  def get_windows_script_output(suffix = '')
+    File.read("#{script_output_path}#{suffix}")
+  end
+
+  def source_contains_case_insensitive_content?( source, content )
+    source.downcase.include?(content.downcase)
+  end
+
+  def get_guard_process_architecture
+    get_process_architecture(guard_script_suffix)
+  end
+
+  def get_process_architecture(suffix = '')
+    get_windows_script_output(suffix).strip.downcase
+  end
+
 end
diff --git a/spec/support/shared/unit/execute_resource.rb b/spec/support/shared/unit/execute_resource.rb
index 609e77ad63..298e0c5baf 100644
--- a/spec/support/shared/unit/execute_resource.rb
+++ b/spec/support/shared/unit/execute_resource.rb
@@ -76,11 +76,6 @@ shared_examples_for "an execute resource" do
     @resource.group.should eql(1)
   end
 
-  it "should accept an array for the execution path" do
-    @resource.path ["woot"]
-    @resource.path.should eql(["woot"])
-  end
-
   it "should accept an integer for the return code" do
     @resource.returns 1
     @resource.returns.should eql(1)
@@ -112,7 +107,6 @@ shared_examples_for "an execute resource" do
       @resource.cwd("/tmp/")
       @resource.environment({ :one => :two })
       @resource.group("legos")
-      @resource.path(["/var/local/"])
       @resource.returns(1)
       @resource.user("root")
     end
@@ -122,4 +116,3 @@ shared_examples_for "an execute resource" do
     end
   end
 end
-
diff --git a/spec/support/shared/unit/resource/static_provider_resolution.rb b/spec/support/shared/unit/resource/static_provider_resolution.rb
new file mode 100644
index 0000000000..147852598a
--- /dev/null
+++ b/spec/support/shared/unit/resource/static_provider_resolution.rb
@@ -0,0 +1,71 @@
+#
+# Author:: Lamont Granquist (<lamont@chef.io>)
+# Copyright:: Copyright (c) 2014 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.
+#
+
+
+
+#
+# This is for typical "static" provider resolution which maps resources onto
+# providers based only on the node data.  Its not really 'static' because it
+# all goes through the Chef::ProviderResolver, but the effective result is
+# a static mapping for the node (unlike the service resource which is
+# complicated).
+#
+def static_provider_resolution(opts={})
+  action           = opts[:action]
+  provider_class   = opts[:provider]
+  resource_class   = opts[:resource]
+  name             = opts[:name]
+  os               = opts[:os]
+  platform_family  = opts[:platform_family]
+  platform_version = opts[:platform_version]
+
+  describe resource_class, "static provider initialization" do
+    let(:node) {
+      node = Chef::Node.new
+      node.automatic_attrs[:os] = os
+      node.automatic_attrs[:platform_family] = platform_family
+      node.automatic_attrs[:platform_version] = platform_version
+      node
+    }
+    let(:events) { Chef::EventDispatch::Dispatcher.new }
+    let(:provider_resolver) { Chef::ProviderResolver.new(node) }
+    let(:run_context) {
+      run_context = Chef::RunContext.new(node, {}, events)
+      run_context.provider_resolver = provider_resolver
+      run_context
+    }
+    let(:resource) { resource_class.new("foo", run_context) }
+
+    it "should return a #{resource_class}" do
+      expect(resource).to be_a_kind_of(resource_class)
+    end
+
+    it "should set the resource_name to #{name}" do
+      expect(resource.resource_name).to eql(name)
+    end
+
+    it "should leave the provider nil" do
+      expect(resource.provider).to eql(nil)
+    end
+
+    it "should resolve to a #{provider_class}" do
+      expect(resource.provider_for_action(action)).to be_a(provider_class)
+    end
+  end
+end
+
diff --git a/spec/support/shared/unit/script_resource.rb b/spec/support/shared/unit/script_resource.rb
index 1137958420..a34f930fc8 100644
--- a/spec/support/shared/unit/script_resource.rb
+++ b/spec/support/shared/unit/script_resource.rb
@@ -72,8 +72,8 @@ shared_examples_for "a script resource" do
 
     it "when guard_interpreter is set to the default value, the guard command string should be evaluated by command execution and not through a resource" do
       Chef::Resource::Conditional.any_instance.should_not_receive(:evaluate_block)
-      Chef::Resource::Conditional.any_instance.should_receive(:evaluate_command).and_return(true)
       Chef::GuardInterpreter::ResourceGuardInterpreter.any_instance.should_not_receive(:evaluate_action)
+      Chef::GuardInterpreter::DefaultGuardInterpreter.any_instance.should_receive(:evaluate).and_return(true)
       resource.only_if 'echo hi'
       resource.should_skip?(:run).should == nil
     end
diff --git a/spec/support/shared/unit/windows_script_resource.rb b/spec/support/shared/unit/windows_script_resource.rb
index 23dbfbe722..888ad600c5 100644
--- a/spec/support/shared/unit/windows_script_resource.rb
+++ b/spec/support/shared/unit/windows_script_resource.rb
@@ -39,8 +39,41 @@ shared_examples_for "a Windows script resource" do
     @resource.should be_a_kind_of(Chef::Resource::WindowsScript)
   end
 
-  context "script" do
-    let(:script_resource) { resource_instance }
+  context "when evaluating guards" do
+    it "should have a default_guard_interpreter attribute that is the same as the resource" do
+      @resource.default_guard_interpreter.should == @resource.resource_name
+    end
+
+    it "should default to using guard_interpreter attribute that is the same as the resource" do
+      @resource.guard_interpreter.should == @resource.resource_name
+    end
+
+    it "should use a resource to evaluate the guard when guard_interpreter is not specified" do
+      Chef::GuardInterpreter::ResourceGuardInterpreter.any_instance.should_receive(:evaluate_action).and_return(true)
+      Chef::GuardInterpreter::DefaultGuardInterpreter.any_instance.should_not_receive(:evaluate)
+      @resource.only_if 'echo hi'
+      @resource.should_skip?(:run).should == nil
+    end
+
+    describe "when the guard is given a ruby block" do
+      it "should evaluate the guard if the guard_interpreter is set to its default value" do
+        @resource.only_if { true }
+        @resource.should_skip?(:run).should == nil
+      end
+
+      it "should raise an exception if the guard_interpreter is overridden from its default value" do
+        @resource.guard_interpreter :bash
+        @resource.only_if { true }
+        expect { @resource.should_skip?(:run) }.to raise_error
+      end
+    end
+  end
+
+  context "script with a default guard interpreter" do
+    let(:script_resource) do
+      resource_instance.guard_interpreter :default
+      resource_instance
+    end
     it_should_behave_like "a script resource"
   end