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

data/spec/unit/knife_spec.rb

@@ -260,8 +260,25 @@ describe Chef::Knife do
         knife_command.configure_chef
         knife_command.config[:opt_with_default].should == "from-cli"
       end
-    end
 
+      context "verbosity is greater than zero" do
+        let(:fake_config) { "/does/not/exist/knife.rb" }
+
+        before do
+          @knife.config[:verbosity] = 1
+          @knife.config[:config_file] = fake_config
+          config_loader = double("Chef::WorkstationConfigLoader", :load => true, :no_config_found? => false, :chef_config_dir => "/etc/chef", :config_location => fake_config)
+          allow(Chef::WorkstationConfigLoader).to receive(:new).and_return(config_loader)
+        end
+
+        it "prints the path to the configuration file used" do
+          @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
+          @knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
+          expect(Chef::Log).to receive(:info).with("Using configuration from #{fake_config}")
+          @knife.configure_chef
+        end
+      end
+    end
   end
 
   describe "when first created" do

data/spec/unit/lwrp_spec.rb

@@ -42,7 +42,8 @@ describe "LWRP" do
       end
 
       Dir[File.expand_path( "lwrp/resources/*", CHEF_SPEC_DATA)].each do |file|
-        Chef::Log.should_receive(:info).with(/overriding/)
+        Chef::Log.should_receive(:info).with(/Skipping/)
+        Chef::Log.should_receive(:debug).with(/anymore/)
         Chef::Resource::LWRPBase.build_from_file("lwrp", file, nil)
       end
     end
@@ -53,16 +54,15 @@ describe "LWRP" do
       end
 
       Dir[File.expand_path( "lwrp/providers/*", CHEF_SPEC_DATA)].each do |file|
-        Chef::Log.should_receive(:info).with(/overriding/)
+        Chef::Log.should_receive(:info).with(/Skipping/)
+        Chef::Log.should_receive(:debug).with(/anymore/)
         Chef::Provider::LWRPBase.build_from_file("lwrp", file, nil)
       end
     end
 
-    it "removes the old LRWP resource class from the list of resource subclasses [CHEF-3432]" do
-      # CHEF-3432 regression test:
-      # Chef::Resource keeps a list of all subclasses to assist class inflation
-      # for json parsing (see Chef::JSONCompat). When replacing LWRP resources,
-      # we need to ensure the old resource class is remove from that list.
+    it "keeps the old LRWP resource class in the list of resource subclasses" do
+      # This was originally CHEF-3432 regression test. But with Chef 12 we are
+      # not replacing the original classes anymore.
       Dir[File.expand_path( "lwrp/resources/*", CHEF_SPEC_DATA)].each do |file|
         Chef::Resource::LWRPBase.build_from_file("lwrp", file, nil)
       end
@@ -71,7 +71,7 @@ describe "LWRP" do
       Dir[File.expand_path( "lwrp/resources/*", CHEF_SPEC_DATA)].each do |file|
         Chef::Resource::LWRPBase.build_from_file("lwrp", file, nil)
       end
-      Chef::Resource.resource_classes.should_not include(first_lwr_foo_class)
+      Chef::Resource.resource_classes.should include(first_lwr_foo_class)
     end
 
     it "does not attempt to remove classes from higher up namespaces [CHEF-4117]" do
@@ -231,6 +231,27 @@ describe "LWRP" do
           expect(child.default_action).to eq(:dont_eat)
         end
       end
+
+      context "when actions are already defined" do
+        let(:child) do
+          Class.new(parent) do
+            actions :eat
+            actions :sleep
+            actions :drink
+          end
+        end
+
+        def raise_if_deprecated!
+          if Chef::VERSION.split('.').first.to_i > 12
+            raise "This test should be removed and the associated code should be removed!"
+          end
+        end
+
+        it "ammends actions when they are already defined" do
+          raise_if_deprecated!
+          expect(child.actions).to eq([:eat, :sleep, :drink])
+        end
+      end
     end
 
   end

data/spec/unit/mixin/homebrew_user_spec.rb

@@ -0,0 +1,100 @@
+#
+# Author:: Joshua Timberman (<joshua@getchef.com>)
+#
+# Copyright 2014, Chef Software, Inc <legal@getchef.com>
+#
+# 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/homebrew_user'
+
+class ExampleHomebrewUser
+  include Chef::Mixin::HomebrewUser
+end
+
+describe Chef::Mixin::HomebrewUser do
+  before(:each) do
+    node.default['homebrew']['owner'] = nil
+  end
+
+  let(:homebrew_user) { ExampleHomebrewUser.new }
+  let(:node) { Chef::Node.new }
+
+  describe 'when the homebrew user is provided' do
+    let(:uid) { 1001 }
+    let(:user) { "foo" }
+
+    it 'returns the homebrew user without looking at the file when uid is provided' do
+      expect(File).to receive(:exist?).exactly(0).times
+      expect(homebrew_user.find_homebrew_uid(uid)).to eq(uid)
+    end
+
+    it 'returns the homebrew user without looking at the file when name is provided' do
+      expect(File).to receive(:exist?).exactly(0).times
+      Etc.stub_chain(:getpwnam, :uid).and_return(uid)
+      expect(homebrew_user.find_homebrew_uid(user)).to eq(uid)
+    end
+
+  end
+
+  shared_examples "successfully find executable" do
+    let(:user) { nil }
+    let(:brew_owner) { 2001 }
+    let(:default_brew_path) { '/usr/local/bin/brew' }
+    let(:stat_double) {
+      d = double()
+      expect(d).to receive(:uid).and_return(brew_owner)
+      d
+    }
+
+    context "debug statement prints owner name" do
+
+      before do
+        expect(Etc).to receive(:getpwuid).with(brew_owner).and_return(OpenStruct.new(:name => "name"))
+      end
+
+      it 'returns the owner of the brew executable when it is at a default location' do
+        expect(File).to receive(:exist?).with(default_brew_path).and_return(true)
+        expect(File).to receive(:stat).with(default_brew_path).and_return(stat_double)
+        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
+      end
+
+      it 'returns the owner of the brew executable when it is not at a default location' do
+        expect(File).to receive(:exist?).with(default_brew_path).and_return(false)
+        homebrew_user.stub_chain(:shell_out, :stdout, :strip).and_return("/foo")
+        expect(File).to receive(:stat).with("/foo").and_return(stat_double)
+        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
+      end
+
+    end
+  end
+
+  describe 'when the homebrew user is not provided' do
+
+    it 'raises an error if no executable is found' do
+      expect(File).to receive(:exist?).with(default_brew_path).and_return(false)
+      homebrew_user.stub_chain(:shell_out, :stdout, :strip).and_return("")
+      expect { homebrew_user.find_homebrew_uid(user) }.to raise_error(Chef::Exceptions::CannotDetermineHomebrewOwner)
+    end
+
+    include_examples "successfully find executable"
+
+    context "the executable is owned by root" do
+      include_examples "successfully find executable" do
+        let(:brew_owner) { 0 }
+      end
+    end
+
+  end
+
+end

data/spec/unit/node_map_spec.rb

@@ -0,0 +1,155 @@
+#
+# 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.
+#
+
+require 'spec_helper'
+require 'chef/node_map'
+
+describe Chef::NodeMap do
+
+  let(:node_map) { Chef::NodeMap.new }
+
+  let(:node) { Chef::Node.new }
+
+  describe "with a bad filter name" do
+    it "should raise an error" do
+      expect{ node_map.set(node, :thing, on_platform_family: 'rhel') }.to raise_error
+    end
+  end
+
+  describe "when no matchers are set at all" do
+    before do
+      node_map.set(:thing, :foo)
+    end
+
+    it "returns the value" do
+      expect(node_map.get(node, :thing)).to eql(:foo)
+    end
+
+    it "returns nil for keys that do not exist" do
+      expect(node_map.get(node, :other_thing)).to eql(nil)
+    end
+  end
+
+  describe "filtering by os" do
+    before do
+      node_map.set(:thing, :foo, os: ["windows"])
+      node_map.set(:thing, :bar, os: "linux")
+    end
+    it "returns the correct value for windows" do
+      allow(node).to receive(:[]).with(:os).and_return("windows")
+      expect(node_map.get(node, :thing)).to eql(:foo)
+    end
+    it "returns the correct value for linux" do
+      allow(node).to receive(:[]).with(:os).and_return("linux")
+      expect(node_map.get(node, :thing)).to eql(:bar)
+    end
+    it "returns nil for a non-matching os" do
+      allow(node).to receive(:[]).with(:os).and_return("freebsd")
+      expect(node_map.get(node, :thing)).to eql(nil)
+    end
+  end
+
+  describe "rejecting an os" do
+    before do
+      node_map.set(:thing, :foo, os: "!windows")
+    end
+    it "returns nil for windows" do
+      allow(node).to receive(:[]).with(:os).and_return("windows")
+      expect(node_map.get(node, :thing)).to eql(nil)
+    end
+    it "returns the correct value for linux" do
+      allow(node).to receive(:[]).with(:os).and_return("linux")
+      expect(node_map.get(node, :thing)).to eql(:foo)
+    end
+  end
+
+  describe "filtering by os and platform_family" do
+    before do
+      node_map.set(:thing, :bar, os: "linux", platform_family: "rhel")
+    end
+
+    it "returns the correct value when both match" do
+      allow(node).to receive(:[]).with(:os).and_return("linux")
+      allow(node).to receive(:[]).with(:platform_family).and_return("rhel")
+      expect(node_map.get(node, :thing)).to eql(:bar)
+    end
+
+    it "returns nil for a non-matching os" do
+      allow(node).to receive(:[]).with(:os).and_return("freebsd")
+      expect(node_map.get(node, :thing)).to eql(nil)
+    end
+
+    it "returns nil when the platform_family does not match" do
+      allow(node).to receive(:[]).with(:os).and_return("linux")
+      allow(node).to receive(:[]).with(:platform_family).and_return("debian")
+      expect(node_map.get(node, :thing)).to eql(nil)
+    end
+  end
+
+  describe "with a block doing platform_version checks" do
+    before do
+      node_map.set(:thing, :foo, platform_family: "rhel") do |node|
+        node[:platform_version].to_i >= 7
+      end
+    end
+
+    it "returns the value when the node matches" do
+      allow(node).to receive(:[]).with(:platform_family).and_return("rhel")
+      allow(node).to receive(:[]).with(:platform_version).and_return("7.0")
+      expect(node_map.get(node, :thing)).to eql(:foo)
+    end
+
+    it "returns nil when the block does not match" do
+      allow(node).to receive(:[]).with(:platform_family).and_return("rhel")
+      allow(node).to receive(:[]).with(:platform_version).and_return("6.4")
+      expect(node_map.get(node, :thing)).to eql(nil)
+    end
+
+    it "returns nil when the platform_family filter does not match" do
+      allow(node).to receive(:[]).with(:platform_family).and_return("debian")
+      allow(node).to receive(:[]).with(:platform_version).and_return("7.0")
+      expect(node_map.get(node, :thing)).to eql(nil)
+    end
+
+    it "returns nil when both do not match" do
+      allow(node).to receive(:[]).with(:platform_family).and_return("debian")
+      allow(node).to receive(:[]).with(:platform_version).and_return("6.0")
+      expect(node_map.get(node, :thing)).to eql(nil)
+    end
+  end
+
+  describe "resource back-compat testing" do
+    it "should handle :on_platforms => :all" do
+      node_map.set(:chef_gem, :foo, :on_platforms => :all)
+      allow(node).to receive(:[]).with(:platform).and_return("windows")
+      expect(node_map.get(node, :chef_gem)).to eql(:foo)
+    end
+    it "should handle :on_platforms => [ 'windows' ]" do
+      node_map.set(:dsc_script, :foo, :on_platforms => [ 'windows' ])
+      allow(node).to receive(:[]).with(:platform).and_return("windows")
+      expect(node_map.get(node, :dsc_script)).to eql(:foo)
+    end
+    it "should handle :on_platform => :all" do
+      node_map.set(:link, :foo, :on_platform => :all)
+      allow(node).to receive(:[]).with(:platform).and_return("windows")
+      expect(node_map.get(node, :link)).to eql(:foo)
+    end
+  end
+
+end
+

data/spec/unit/node_spec.rb

@@ -700,6 +700,10 @@ describe Chef::Node do
       h["run_list"].should be_include("recipe[stalinist]")
       h["chef_environment"].should == "dev"
     end
+
+    it 'should return an empty array for empty run_list' do
+      node.to_hash["run_list"].should == []
+    end
   end
 
   describe "converting to or from json" do
@@ -762,6 +766,13 @@ describe Chef::Node do
       end
       serialized_node.run_list.should == node.run_list
     end
+
+    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+      let(:jsonable) {
+        node.from_file(File.expand_path("nodes/test.example.com.rb", CHEF_SPEC_DATA))
+        node
+      }
+    end
   end
 
   describe "to_s" do

data/spec/unit/platform/query_helpers_spec.rb

@@ -30,3 +30,26 @@ describe "Chef::Platform#windows_server_2003?" do
     expect { Thread.fork { Chef::Platform.windows_server_2003? }.join }.not_to raise_error
   end
 end
+
+describe 'Chef::Platform#supports_dsc?' do 
+  it 'returns false if powershell is not present' do
+    node = Chef::Node.new
+    Chef::Platform.supports_dsc?(node).should be_false
+  end
+
+  ['1.0', '2.0', '3.0'].each do |version|
+    it "returns false for Powershell #{version}" do
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = version
+      Chef::Platform.supports_dsc?(node).should be_false
+    end
+  end
+
+  ['4.0', '5.0'].each do |version|
+    it "returns true for Powershell #{version}" do
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = version
+      Chef::Platform.supports_dsc?(node).should be_true
+    end
+  end
+end

data/spec/unit/platform_spec.rb

@@ -278,6 +278,29 @@ describe Chef::Platform do
       pmap[:package].should eql(Chef::Provider::Package::Ips)
     end
 
+    it "should use the Redhat service provider on SLES11" do
+      1.upto(3) do |sp|
+        pmap = Chef::Platform.find("SUSE", "11.#{sp}")
+        pmap[:service].should eql(Chef::Provider::Service::Redhat)
+      end
+    end
+
+    it "should use the Systemd service provider on SLES12" do
+      pmap = Chef::Platform.find("SUSE", "12.0")
+      pmap[:service].should eql(Chef::Provider::Service::Systemd)
+    end
+
+    it "should use the SUSE group provider on SLES11" do
+      1.upto(3) do |sp|
+        pmap = Chef::Platform.find("SUSE", "11.#{sp}")
+        pmap[:group].should eql(Chef::Provider::Group::Suse)
+      end
+    end
+
+    it "should use the Gpasswd group provider on SLES12" do
+      pmap = Chef::Platform.find("SUSE", "12.0")
+      pmap[:group].should eql(Chef::Provider::Group::Gpasswd)
+    end
   end
 
 end

data/spec/unit/provider/breakpoint_spec.rb

@@ -26,28 +26,28 @@ describe Chef::Provider::Breakpoint do
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
     @collection = double("resource collection")
-    @run_context.stub(:resource_collection).and_return(@collection)
+    allow(@run_context).to receive(:resource_collection).and_return(@collection)
     @provider = Chef::Provider::Breakpoint.new(@resource, @run_context)
   end
 
   it "responds to load_current_resource" do
-    @provider.should respond_to(:load_current_resource)
+    expect(@provider).to respond_to(:load_current_resource)
   end
 
   it "gets the iterator from @collection and pauses it" do
-    Shell.stub(:running?).and_return(true)
+    allow(Shell).to receive(:running?).and_return(true)
     @iterator = double("stepable_iterator")
-    @collection.stub(:iterator).and_return(@iterator)
-    @iterator.should_receive(:pause)
+    allow(@collection).to receive(:iterator).and_return(@iterator)
+    expect(@iterator).to receive(:pause)
     @provider.action_break
-    @resource.should be_updated
+    expect(@resource).to be_updated
   end
 
   it "doesn't pause the iterator if chef-shell isn't running" do
-    Shell.stub(:running?).and_return(false)
+    allow(Shell).to receive(:running?).and_return(false)
     @iterator = double("stepable_iterator")
-    @collection.stub(:iterator).and_return(@iterator)
-    @iterator.should_not_receive(:pause)
+    allow(@collection).to receive(:iterator).and_return(@iterator)
+    expect(@iterator).not_to receive(:pause)
     @provider.action_break
   end