chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/spec/support/chef_helpers.rb

@@ -14,6 +14,7 @@
 # limitations under the License.
 #
 CHEF_SPEC_DATA = File.expand_path(File.dirname(__FILE__) + "/../data/")
+CHEF_SPEC_ASSETS = File.expand_path(File.dirname(__FILE__) + "/../functional/assets/")
 CHEF_SPEC_BACKUP_PATH = File.join(Dir.tmpdir, 'test-backup-path')
 
 Chef::Config[:log_level] = :fatal

data/spec/support/lib/chef/provider/snakeoil.rb

@@ -19,6 +19,7 @@
 class Chef
   class Provider
     class SnakeOil < Chef::Provider
+
       def load_current_resource
         true
       end

data/spec/support/lib/chef/resource/zen_follower.rb

@@ -21,20 +21,14 @@ require 'chef/json_compat'
 class Chef
   class Resource
     class ZenFollower < Chef::Resource
-      attr_accessor :created_as_type
 
-      provides :follower, :on_platforms => ["zen"]
+      provides :follower, platform: "zen"
 
       def initialize(name, run_context=nil)
         @resource_name = :zen_follower
-        @created_as_type = "zen_follower"
         super
       end
 
-      def to_s
-        "#{created_as_type}[#{name}]"
-      end
-
       def master(arg=nil)
         if !arg.nil?
           @master = arg

data/spec/support/platform_helpers.rb

@@ -52,6 +52,30 @@ def windows_win2k3?
   (host['version'] && host['version'].start_with?("5.2"))
 end
 
+def windows_2008r2_or_later?
+  return false unless windows?
+  wmi = WmiLite::Wmi.new
+  host = wmi.first_of('Win32_OperatingSystem')
+  version = host['version']
+  return false unless version
+  components = version.split('.').map do | component |
+    component.to_i
+  end
+  components.length >=2 && components[0] >= 6 && components[1] >= 1
+end
+
+def windows_powershell_dsc?
+  return false unless windows?
+  supports_dsc = false
+  begin
+    wmi = WmiLite::Wmi.new('root/microsoft/windows/desiredstateconfiguration')
+    lcm = wmi.query("SELECT * FROM meta_class WHERE __this ISA 'MSFT_DSCLocalConfigurationManager'")
+    supports_dsc = !! lcm
+  rescue WmiLite::WmiException
+  end
+  supports_dsc
+end
+
 def mac_osx_106?
   if File.exists? "/usr/bin/sw_vers"
     result = shell_out("/usr/bin/sw_vers")
@@ -141,3 +165,7 @@ end
 def openssl_lt_101?
   !openssl_gte_101?
 end
+
+def aes_256_gcm?
+  OpenSSL::Cipher.ciphers.include?("aes-256-gcm")
+end

data/spec/support/shared/functional/file_resource.rb

@@ -284,6 +284,7 @@ shared_examples_for "a file resource" do
 
     before do
       Chef::Config[:why_run] = true
+      Chef::Config[:ssl_verify_mode] = :verify_none
     end
 
     after do
@@ -333,6 +334,10 @@ shared_examples_for "file resource not pointing to a real file" do
     !symlink?(file_path) && File.file?(file_path)
   end
 
+  before do
+    Chef::Config[:ssl_verify_mode] = :verify_none
+  end
+
   describe "when force_unlink is set to true" do
     it ":create unlinks the target" do
       real_file?(path).should be_false
@@ -363,6 +368,7 @@ shared_examples_for "a configured file resource" do
 
   before do
     Chef::Log.level = :info
+    Chef::Config[:ssl_verify_mode] = :verify_none
   end
 
    # note the stripping of the drive letter from the tmpdir on windows

data/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", :windows64_only 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

data/spec/support/shared/integration/integration_helper.rb

@@ -72,7 +72,7 @@ module IntegrationSupport
     File.open(filename, 'w') do |file|
       raw = case contents
             when Hash, Array
-              JSON.pretty_generate(contents)
+              Chef::JSONCompat.to_json_pretty(contents)
             else
               contents
             end
@@ -118,7 +118,10 @@ module IntegrationSupport
             Chef::Config.delete("#{object_name}_path".to_sym)
           end
           Chef::Config.delete(:chef_repo_path)
-          FileUtils.remove_entry_secure(@repository_dir)
+          # TODO: "force" actually means "silence all exceptions". this
+          # silences a weird permissions error on Windows that we should track
+          # down, but for now there's no reason for it to blow up our CI.
+          FileUtils.remove_entry_secure(@repository_dir, force=Chef::Platform.windows?)
         ensure
           @repository_dir = nil
         end

data/spec/support/shared/matchers/exit_with_code.rb

@@ -0,0 +1,28 @@
+require 'rspec/expectations'
+
+# Lifted from http://stackoverflow.com/questions/1480537/how-can-i-validate-exits-and-aborts-in-rspec
+RSpec::Matchers.define :exit_with_code do |exp_code|
+  actual = nil
+  match do |block|
+    begin
+      block.call
+    rescue SystemExit => e
+      actual = e.status
+    end
+    actual and actual == exp_code
+  end
+
+  failure_message_for_should do |block|
+    "expected block to call exit(#{exp_code}) but exit" +
+        (actual.nil? ? " not called" : "(#{actual}) was called")
+  end
+
+  failure_message_for_should_not do |block|
+    "expected block not to call exit(#{exp_code})"
+  end
+
+  description do
+    "expect block to call exit(#{exp_code})"
+  end
+
+end

data/spec/support/shared/matchers/match_environment_variable.rb

@@ -0,0 +1,17 @@
+
+require 'rspec/expectations'
+require 'spec/support/platform_helpers'
+
+RSpec::Matchers.define :match_environment_variable do |varname|
+  match do |actual|
+    expected = if windows? && ENV[varname].nil?
+                 # On Windows, if an environment variable is not set, the command
+                 # `echo %VARNAME%` outputs %VARNAME%
+                 "%#{varname}%"
+               else
+                 ENV[varname].to_s
+               end
+
+    actual == expected
+  end
+end

data/spec/support/shared/shared_examples.rb

@@ -0,0 +1,14 @@
+# For storing any examples shared between multiple tests
+
+# Any object which defines a .to_json should import this test
+shared_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+
+  let(:jsonable) {
+    raise "You must define the subject when including this test"
+  }
+
+  it "should allow consumers to call #to_json or Chef::JSONCompat.to_json" do
+    expect(jsonable.to_json).to eq(Chef::JSONCompat.to_json(jsonable))
+  end
+
+end

data/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
-

data/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
+

data/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

data/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