chef 12.1.2-x86-mingw32 → 12.2.0.rc.1-x86-mingw32

data/spec/unit/mixin/params_validate_spec.rb

@@ -339,69 +339,83 @@ describe Chef::Mixin::ParamsValidate do
     end.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 
-  it "should set and return a value, then return the same value" do
-    value = "meow"
-    expect(@vo.set_or_return(:test, value, {}).object_id).to eq(value.object_id)
-    expect(@vo.set_or_return(:test, nil, {}).object_id).to eq(value.object_id)
+  def self.test_set_or_return_method(method)
+    # caller is responsible for passing in the right arg to get 'return' behavior
+    return_arg = method == :nillable_set_or_return ? TinyClass::NULL_ARG : nil
+
+    it "#{method} should set and return a value, then return the same value" do
+      value = "meow"
+      expect(@vo.send(method,:test, value, {}).object_id).to eq(value.object_id)
+      expect(@vo.send(method,:test, return_arg, {}).object_id).to eq(value.object_id)
+    end
+
+    it "#{method} should set and return a default value when the argument is nil, then return the same value" do
+      value = "meow"
+      expect(@vo.send(method,:test, return_arg, { :default => value }).object_id).to eq(value.object_id)
+      expect(@vo.send(method,:test, return_arg, {}).object_id).to eq(value.object_id)
+    end
+
+    it "#{method} should raise an ArgumentError when argument is nil and required is true" do
+      expect {
+        @vo.send(method,:test, return_arg, { :required => true })
+      }.to raise_error(ArgumentError)
+    end
+
+    it "#{method} should not raise an error when argument is nil and required is false" do
+      expect {
+        @vo.send(method,:test, return_arg, { :required => false })
+      }.not_to raise_error
+    end
+
+    it "#{method} should set and return @name, then return @name for foo when argument is nil" do
+      value = "meow"
+      expect(@vo.send(method,:name, value, { }).object_id).to eq(value.object_id)
+      expect(@vo.send(method,:foo, return_arg, { :name_attribute => true }).object_id).to eq(value.object_id)
+    end
+
+    it "#{method} should allow DelayedEvaluator instance to be set for value regardless of restriction" do
+      value = Chef::DelayedEvaluator.new{ 'test' }
+      @vo.send(method,:test, value, {:kind_of => Numeric})
+    end
+
+    it "#{method} should raise an error when delayed evaluated attribute is not valid" do
+      value = Chef::DelayedEvaluator.new{ 'test' }
+      @vo.send(method,:test, value, {:kind_of => Numeric})
+      expect do
+        @vo.send(method,:test, return_arg, {:kind_of => Numeric})
+      end.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+
+    it "#{method} should create DelayedEvaluator instance when #lazy is used" do
+      @vo.send(method,:delayed, @vo.lazy{ 'test' }, {})
+      expect(@vo.instance_variable_get(:@delayed)).to be_a(Chef::DelayedEvaluator)
+    end
+
+    it "#{method} should execute block on each call when DelayedEvaluator" do
+      value = 'fubar'
+      @vo.send(method,:test, @vo.lazy{ value }, {})
+      expect(@vo.send(method,:test, return_arg, {})).to eq('fubar')
+      value = 'foobar'
+      expect(@vo.send(method,:test, return_arg, {})).to eq('foobar')
+      value = 'fauxbar'
+      expect(@vo.send(method,:test, return_arg, {})).to eq('fauxbar')
+    end
+
+    it "#{method} should not evaluate non DelayedEvaluator instances" do
+      value = lambda{ 'test' }
+      @vo.send(method,:test, value, {})
+      expect(@vo.send(method,:test, return_arg, {}).object_id).to eq(value.object_id)
+      expect(@vo.send(method,:test, return_arg, {})).to be_a(Proc)
+    end
   end
 
-  it "should set and return a default value when the argument is nil, then return the same value" do
-    value = "meow"
-    expect(@vo.set_or_return(:test, nil, { :default => value }).object_id).to eq(value.object_id)
-    expect(@vo.set_or_return(:test, nil, {}).object_id).to eq(value.object_id)
-  end
-
-  it "should raise an ArgumentError when argument is nil and required is true" do
-    expect {
-      @vo.set_or_return(:test, nil, { :required => true })
-    }.to raise_error(ArgumentError)
-  end
-
-  it "should not raise an error when argument is nil and required is false" do
-    expect {
-      @vo.set_or_return(:test, nil, { :required => false })
-    }.not_to raise_error
-  end
-
-  it "should set and return @name, then return @name for foo when argument is nil" do
-    value = "meow"
-    expect(@vo.set_or_return(:name, value, { }).object_id).to eq(value.object_id)
-    expect(@vo.set_or_return(:foo, nil, { :name_attribute => true }).object_id).to eq(value.object_id)
-  end
+  test_set_or_return_method(:set_or_return)
+  test_set_or_return_method(:nillable_set_or_return)
 
-  it "should allow DelayedEvaluator instance to be set for value regardless of restriction" do
-    value = Chef::DelayedEvaluator.new{ 'test' }
-    @vo.set_or_return(:test, value, {:kind_of => Numeric})
+  it "nillable_set_or_return supports nilling values" do
+    expect(@vo.nillable_set_or_return(:test, "meow", {})).to eq("meow")
+    expect(@vo.nillable_set_or_return(:test, TinyClass::NULL_ARG, {})).to eq("meow")
+    expect(@vo.nillable_set_or_return(:test, nil, {})).to be_nil
+    expect(@vo.nillable_set_or_return(:test, TinyClass::NULL_ARG, {})).to be_nil
   end
-
-  it "should raise an error when delayed evaluated attribute is not valid" do
-    value = Chef::DelayedEvaluator.new{ 'test' }
-    @vo.set_or_return(:test, value, {:kind_of => Numeric})
-    expect do
-      @vo.set_or_return(:test, nil, {:kind_of => Numeric})
-    end.to raise_error(Chef::Exceptions::ValidationFailed)
-  end
-
-  it "should create DelayedEvaluator instance when #lazy is used" do
-    @vo.set_or_return(:delayed, @vo.lazy{ 'test' }, {})
-    expect(@vo.instance_variable_get(:@delayed)).to be_a(Chef::DelayedEvaluator)
-  end
-
-  it "should execute block on each call when DelayedEvaluator" do
-    value = 'fubar'
-    @vo.set_or_return(:test, @vo.lazy{ value }, {})
-    expect(@vo.set_or_return(:test, nil, {})).to eq('fubar')
-    value = 'foobar'
-    expect(@vo.set_or_return(:test, nil, {})).to eq('foobar')
-    value = 'fauxbar'
-    expect(@vo.set_or_return(:test, nil, {})).to eq('fauxbar')
-  end
-
-  it "should not evaluate non DelayedEvaluator instances" do
-    value = lambda{ 'test' }
-    @vo.set_or_return(:test, value, {})
-    expect(@vo.set_or_return(:test, nil, {}).object_id).to eq(value.object_id)
-    expect(@vo.set_or_return(:test, nil, {})).to be_a(Proc)
-  end
-
 end

data/spec/unit/mixin/powershell_type_coercions_spec.rb

@@ -0,0 +1,72 @@
+#
+# Author:: Jay Mundrawala (<jdm@chef.io>)
+# Copyright:: Copyright (c) 2015 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 'spec_helper'
+require 'chef/mixin/powershell_type_coercions'
+require 'base64'
+
+class Chef::PSTypeTester
+  include Chef::Mixin::PowershellTypeCoercions
+end
+
+describe Chef::Mixin::PowershellTypeCoercions do
+  let (:test_class) { Chef::PSTypeTester.new }
+
+  describe '#translate_type' do
+    it 'should single quote a string' do
+      expect(test_class.translate_type('foo')).to eq("'foo'")
+    end
+
+    ["'", '"', '#', '`'].each do |c|
+      it "should base64 encode a string that contains #{c}" do
+        expect(test_class.translate_type("#{c}")).to match(Base64.strict_encode64(c))
+      end
+    end
+
+    it 'should not quote an integer' do
+      expect(test_class.translate_type(123)).to eq('123')
+    end
+
+    it 'should not quote a floating point number' do
+      expect(test_class.translate_type(123.4)).to eq('123.4')
+    end
+
+    it 'should return $false when an instance of FalseClass is provided' do
+      expect(test_class.translate_type(false)).to eq('$false')
+    end
+
+    it 'should return $true when an instance of TrueClass is provided' do
+      expect(test_class.translate_type(true)).to eq('$true')
+    end
+
+    it 'should translate all members of a hash and wrap them in @{} separated by ;' do
+      expect(test_class.translate_type({"a" => 1, "b" => 1.2, "c" => false, "d" => true
+      })).to eq("@{a=1;b=1.2;c=$false;d=$true}")
+    end
+
+    it 'should translat all members of an array and them by a ,' do
+      expect(test_class.translate_type([true, false])).to eq('@($true,$false)')
+    end
+
+    it 'should fall back :to_psobject if we have not defined at explicit rule' do
+      ps_obj = double("PSObject")
+      expect(ps_obj).to receive(:to_psobject).and_return('$true')
+      expect(test_class.translate_type(ps_obj)).to eq('($true)')
+    end
+  end
+end

data/spec/unit/platform/query_helpers_spec.rb

@@ -53,3 +53,25 @@ describe 'Chef::Platform#supports_dsc?' do
     end
   end
 end
+
+describe 'Chef::Platform#supports_dsc_invoke_resource?' do 
+  it 'returns false if powershell is not present' do
+    node = Chef::Node.new
+    expect(Chef::Platform.supports_dsc_invoke_resource?(node)).to be_falsey
+  end
+
+  ['1.0', '2.0', '3.0', '4.0', '5.0.10017.9'].each do |version|
+    it "returns false for Powershell #{version}" do
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = version
+      expect(Chef::Platform.supports_dsc_invoke_resource?(node)).to be_falsey
+    end
+  end
+
+  it "returns true for Powershell 5.0.10018.0" do
+    node = Chef::Node.new
+    node.automatic[:languages][:powershell][:version] = "5.0.10018.0"
+    expect(Chef::Platform.supports_dsc_invoke_resource?(node)).to be_truthy
+  end
+end
+

data/spec/unit/platform_spec.rb

@@ -20,8 +20,6 @@ require 'spec_helper'
 
 describe "Chef::Platform supports" do
   [
-    :mac_os_x,
-    :mac_os_x_server,
     :freebsd,
     :ubuntu,
     :debian,
@@ -34,9 +32,6 @@ describe "Chef::Platform supports" do
     :gentoo,
     :arch,
     :solaris,
-    :mswin,
-    :mingw32,
-    :windows,
     :gcel,
     :ibm_powerkvm
   ].each do |platform|

data/spec/unit/provider/dsc_resource_spec.rb

@@ -0,0 +1,84 @@
+#
+# Author:: Jay Mundrawala (<jdm@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.
+#
+
+require 'chef'
+require 'spec_helper'
+
+describe Chef::Provider::DscResource do
+  let (:events) { Chef::EventDispatch::Dispatcher.new }
+  let (:run_context) { Chef::RunContext.new(node, {}, events) }
+  let (:resource) { Chef::Resource::DscResource.new("dscresource", run_context) }
+  let (:provider) do
+    Chef::Provider::DscResource.new(resource, run_context)
+  end
+
+  context 'when Powershell does not support Invoke-DscResource' do
+    let (:node) {
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = '4.0'
+      node
+    }
+
+    it 'raises a NoProviderAvailable exception' do
+      expect(provider).not_to receive(:meta_configuration)
+      expect{provider.run_action(:run)}.to raise_error(
+              Chef::Exceptions::NoProviderAvailable, /5\.0\.10018\.0/)
+    end
+  end
+
+  context 'when Powershell supports Invoke-DscResource' do
+    let (:node) {
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = '5.0.10018.0'
+      node
+    }
+
+    context 'when RefreshMode is not set to Disabled' do
+      let (:meta_configuration) { {'RefreshMode' => 'AnythingElse'}}
+
+      it 'raises an exception' do
+        expect(provider).to receive(:meta_configuration).and_return(
+                                                             meta_configuration)
+        expect { provider.run_action(:run) }.to raise_error(
+          Chef::Exceptions::NoProviderAvailable, /Disabled/)
+      end
+    end
+
+    context 'when RefreshMode is set to Disabled' do
+      let (:meta_configuration) { {'RefreshMode' => 'Disabled'}}
+
+      it 'does not update the resource if it is up to date' do
+        expect(provider).to receive(:meta_configuration).and_return(
+                                                             meta_configuration)
+        expect(provider).to receive(:test_resource).and_return(true)
+        provider.run_action(:run)
+        expect(resource).not_to be_updated
+      end
+
+      it 'converges the resource if it is not up to date' do
+        expect(provider).to receive(:meta_configuration).and_return(
+                                                             meta_configuration)
+        expect(provider).to receive(:test_resource).and_return(false)
+        expect(provider).to receive(:set_resource)
+        provider.run_action(:run)
+        expect(resource).to be_updated
+      end
+    end
+  end
+end

data/spec/unit/provider/package/openbsd_spec.rb

@@ -21,28 +21,116 @@ require 'ostruct'
 
 describe Chef::Provider::Package::Openbsd do
 
+  let(:node) do
+    node = Chef::Node.new
+    node.default['kernel'] = {'name' => 'OpenBSD', 'release' => '5.5', 'machine' => 'amd64'}
+    node
+  end
+
+  let (:provider) do
+    events = Chef::EventDispatch::Dispatcher.new
+    run_context = Chef::RunContext.new(node, {}, events)
+    Chef::Provider::Package::Openbsd.new(new_resource, run_context)
+  end
+
+  let(:new_resource) { Chef::Resource::Package.new(name)}
+
   before(:each) do
-    @node = Chef::Node.new
-    @node.default['kernel'] = {'name' => 'OpenBSD', 'release' => '5.5', 'machine' => 'amd64'}
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
     ENV['PKG_PATH'] = nil
   end
 
   describe "install a package" do
-    before do
-      @name = 'ihavetoes'
-      @new_resource     = Chef::Resource::Package.new(@name)
-      @current_resource = Chef::Resource::Package.new(@name)
-      @provider = Chef::Provider::Package::Openbsd.new(@new_resource, @run_context)
-      @provider.current_resource = @current_resource
-    end
-    it "should run the installation command" do
-      expect(@provider).to receive(:shell_out!).with(
-        "pkg_add -r #{@name}",
-        {:env => {"PKG_PATH" => "http://ftp.OpenBSD.org/pub/OpenBSD/5.5/packages/amd64/"}}
-      ) {OpenStruct.new :status => true}
-      @provider.install_package(@name, nil)
+    let(:name) { 'ihavetoes' }
+    let(:version) {'0.0'}
+
+    context 'when not already installed' do
+      before do
+        allow(provider).to receive(:shell_out!).with("pkg_info -e \"#{name}->0\"", anything()).and_return(instance_double('shellout', :stdout => ''))
+      end
+
+      context 'when there is a single candidate' do
+
+        context 'when installing from source' do
+          it 'should run the installation command' do
+            pending('Installing from source is not supported yet')
+            # This is a consequence of load_current_resource being called before define_resource_requirements
+            # It can be deleted once an implementation is provided
+            allow(provider).to receive(:shell_out!).with("pkg_info -I \"#{name}\"", anything()).and_return(
+              instance_double('shellout', :stdout => "#{name}-#{version}\n"))
+            new_resource.source('/some/path/on/disk.tgz')
+            provider.run_action(:install)
+          end
+        end
+
+        context 'when source is not provided' do
+          it 'should run the installation command' do
+            expect(provider).to receive(:shell_out!).with("pkg_info -I \"#{name}\"", anything()).and_return(
+              instance_double('shellout', :stdout => "#{name}-#{version}\n"))
+            expect(provider).to receive(:shell_out!).with(
+              "pkg_add -r #{name}-#{version}",
+              {:env => {"PKG_PATH" => "http://ftp.OpenBSD.org/pub/OpenBSD/5.5/packages/amd64/"}}
+            ) {OpenStruct.new :status => true}
+            provider.run_action(:install)
+          end
+        end
+      end
+
+      context 'when there are multiple candidates' do
+        let(:flavor_a) { 'flavora' }
+        let(:flavor_b) { 'flavorb' }
+
+        context 'if no version is specified' do
+          it 'should raise an exception' do
+            expect(provider).to receive(:shell_out!).with("pkg_info -I \"#{name}\"", anything()).and_return(
+              instance_double('shellout', :stdout => "#{name}-#{version}-#{flavor_a}\n#{name}-#{version}-#{flavor_b}\n"))
+            expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /multiple matching candidates/)
+          end
+        end
+
+        context 'if a flavor is specified' do
+
+          let(:flavor) { 'flavora' }
+          let(:package_name) {'ihavetoes' }
+          let(:name) { "#{package_name}--#{flavor}" }
+
+          context 'if no version is specified' do
+            it 'should run the installation command' do
+              expect(provider).to receive(:shell_out!).with("pkg_info -e \"#{package_name}->0\"", anything()).and_return(instance_double('shellout', :stdout => ''))
+              expect(provider).to receive(:shell_out!).with("pkg_info -I \"#{name}\"", anything()).and_return(
+                instance_double('shellout', :stdout => "#{name}-#{version}-#{flavor}\n"))
+              expect(provider).to receive(:shell_out!).with(
+                "pkg_add -r #{name}-#{version}-#{flavor}",
+                {:env => {"PKG_PATH" => "http://ftp.OpenBSD.org/pub/OpenBSD/5.5/packages/amd64/"}}
+              ) {OpenStruct.new :status => true}
+              provider.run_action(:install)
+            end
+          end
+
+          context 'if a version is specified' do
+            it 'runs the installation command' do
+              pending('Specifying both a version and flavor is not supported')
+              new_resource.version(version)
+              allow(provider).to receive(:shell_out!).with(/pkg_info -e/, anything()).and_return(instance_double('shellout', :stdout => ''))
+              allow(provider).to receive(:candidate_version).and_return("#{package_name}-#{version}-#{flavor}")
+              provider.run_action(:install)
+            end
+          end
+        end
+
+        context 'if a version is specified' do
+          it 'should use the flavor from the version' do
+            expect(provider).to receive(:shell_out!).with("pkg_info -I \"#{name}-#{version}-#{flavor_b}\"", anything()).and_return(
+              instance_double('shellout', :stdout => "#{name}-#{version}-#{flavor_a}\n"))
+
+            new_resource.version("#{version}-#{flavor_b}")
+            expect(provider).to receive(:shell_out!).with(
+              "pkg_add -r #{name}-#{version}-#{flavor_b}",
+              {:env => {"PKG_PATH" => "http://ftp.OpenBSD.org/pub/OpenBSD/5.5/packages/amd64/"}}
+            ) {OpenStruct.new :status => true}
+            provider.run_action(:install)
+          end
+        end
+      end
     end
   end