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

data/spec/unit/resource/windows_package_spec.rb

@@ -18,7 +18,18 @@
 
 require 'spec_helper'
 
-describe Chef::Resource::WindowsPackage, "initialize", :windows_only do
+describe Chef::Resource::WindowsPackage, "initialize" do
+  before(:each) do
+    stub_const("File::ALT_SEPARATOR", "\\")
+  end
+
+  static_provider_resolution(
+    resource: Chef::Resource::WindowsPackage,
+    provider: Chef::Provider::Package::Windows,
+    os: "windows",
+    name: :windows_package,
+    action: :start
+  )
 
   let(:resource) { Chef::Resource::WindowsPackage.new("solitaire.msi") }
 
@@ -30,13 +41,9 @@ describe Chef::Resource::WindowsPackage, "initialize", :windows_only do
     expect(resource.resource_name).to eql(:windows_package)
   end
 
-  it "sets the provider to Chef::Provider::Package::Windows" do
-    expect(resource.provider).to eql(Chef::Provider::Package::Windows)
-  end
-
-  it "supports setting installer_type" do
-    resource.installer_type("msi")
-    expect(resource.installer_type).to eql("msi")
+  it "supports setting installer_type as a symbol" do
+    resource.installer_type(:msi)
+    expect(resource.installer_type).to eql(:msi)
   end
 
   # String, Integer
@@ -56,13 +63,13 @@ describe Chef::Resource::WindowsPackage, "initialize", :windows_only do
   end
 
   it "coverts a source to an absolute path" do
-    ::File.stub(:absolute_path).and_return("c:\\Files\\frost.msi")
+    allow(::File).to receive(:absolute_path).and_return("c:\\Files\\frost.msi")
     resource.source("frost.msi")
     expect(resource.source).to eql "c:\\Files\\frost.msi"
   end
 
   it "converts slashes to backslashes in the source path" do
-    ::File.stub(:absolute_path).and_return("c:\\frost.msi")
+    allow(::File).to receive(:absolute_path).and_return("c:\\frost.msi")
     resource.source("c:/frost.msi")
     expect(resource.source).to eql "c:\\frost.msi"
   end

data/spec/unit/resource/windows_service_spec.rb

@@ -18,7 +18,14 @@
 
 require 'spec_helper'
 
-describe Chef::Resource::WindowsService, "initialize", :windows_only do
+describe Chef::Resource::WindowsService, "initialize" do
+  static_provider_resolution(
+    resource: Chef::Resource::WindowsService,
+    provider: Chef::Provider::Service::Windows,
+    os: "windows",
+    name: :windows_service,
+    action: :start
+  )
 
   let(:resource) { Chef::Resource::WindowsService.new("BITS") }
 
@@ -30,10 +37,6 @@ describe Chef::Resource::WindowsService, "initialize", :windows_only do
     expect(resource.resource_name).to eql(:windows_service)
   end
 
-  it "sets the provider to Chef::Provider::Service::Windows" do
-    expect(resource.provider).to eql(Chef::Provider::Service::Windows)
-  end
-
   it "supports setting startup_type" do
     resource.startup_type(:manual)
     expect(resource.startup_type).to eql(:manual)
@@ -41,6 +44,6 @@ describe Chef::Resource::WindowsService, "initialize", :windows_only do
 
   it "allows the action to be 'configure_startup'" do
     resource.action :configure_startup
-    resource.action.should == [:configure_startup]
+    expect(resource.action).to eq([:configure_startup])
   end
 end

data/spec/unit/resource/yum_package_spec.rb

@@ -17,24 +17,19 @@
 #
 
 require 'spec_helper'
+require 'support/shared/unit/resource/static_provider_resolution'
 
 describe Chef::Resource::YumPackage, "initialize" do
 
-  before(:each) do
-    @resource = Chef::Resource::YumPackage.new("foo")
-  end
-
-  it "should return a Chef::Resource::YumPackage" do
-    @resource.should be_a_kind_of(Chef::Resource::YumPackage)
-  end
-
-  it "should set the resource_name to :yum_package" do
-    @resource.resource_name.should eql(:yum_package)
-  end
+  static_provider_resolution(
+    resource: Chef::Resource::YumPackage,
+    provider: Chef::Provider::Package::Yum,
+    name: :yum_package,
+    action: :install,
+    os: 'linux',
+    platform_family: 'rhel',
+  )
 
-  it "should set the provider to Chef::Provider::Package::Yum" do
-    @resource.provider.should eql(Chef::Provider::Package::Yum)
-  end
 end
 
 describe Chef::Resource::YumPackage, "arch" do
@@ -44,7 +39,7 @@ describe Chef::Resource::YumPackage, "arch" do
 
   it "should set the arch variable to whatever is passed in" do
     @resource.arch("i386")
-    @resource.arch.should eql("i386")
+    expect(@resource.arch).to eql("i386")
   end
 end
 
@@ -55,20 +50,20 @@ describe Chef::Resource::YumPackage, "flush_cache" do
 
   it "should default the flush timing to false" do
     flush_hash = { :before => false, :after => false }
-    @resource.flush_cache.should == flush_hash
+    expect(@resource.flush_cache).to eq(flush_hash)
   end
 
   it "should allow you to set the flush timing with an array" do
     flush_array = [ :before, :after ]
     flush_hash = { :before => true, :after => true }
     @resource.flush_cache(flush_array)
-    @resource.flush_cache.should == flush_hash
+    expect(@resource.flush_cache).to eq(flush_hash)
   end
 
   it "should allow you to set the flush timing with a hash" do
     flush_hash = { :before => true, :after => true }
     @resource.flush_cache(flush_hash)
-    @resource.flush_cache.should == flush_hash
+    expect(@resource.flush_cache).to eq(flush_hash)
   end
 end
 
@@ -78,8 +73,8 @@ describe Chef::Resource::YumPackage, "allow_downgrade" do
   end
 
   it "should allow you to specify whether allow_downgrade is true or false" do
-    lambda { @resource.allow_downgrade true }.should_not raise_error
-    lambda { @resource.allow_downgrade false }.should_not raise_error
-    lambda { @resource.allow_downgrade "monkey" }.should raise_error(ArgumentError)
+    expect { @resource.allow_downgrade true }.not_to raise_error
+    expect { @resource.allow_downgrade false }.not_to raise_error
+    expect { @resource.allow_downgrade "monkey" }.to raise_error(ArgumentError)
   end
 end

data/spec/unit/resource_collection/resource_list_spec.rb

@@ -0,0 +1,137 @@
+#
+# Author:: Serdar Sutay (<serdar@getchef.com>)
+# 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'
+
+describe Chef::ResourceCollection::ResourceList do
+  let(:resource_list) { Chef::ResourceCollection::ResourceList.new() }
+  let(:resource) { Chef::Resource::ZenMaster.new("makoto") }
+  let(:second_resource) { Chef::Resource::ZenMaster.new("hattori") }
+
+  def insert_resource(res)
+    expect{ resource_list.insert(res) }.not_to raise_error
+  end
+
+  describe "initialize" do
+    it "should return a Chef::ResourceList" do
+      expect(resource_list).to be_instance_of(Chef::ResourceCollection::ResourceList)
+    end
+  end
+
+  describe "insert" do
+    it "should be able to insert a Chef::Resource" do
+      insert_resource(resource)
+      expect(resource_list[0]).to be(resource)
+    end
+
+    it "should insert things in order" do
+      insert_resource(resource)
+      insert_resource(second_resource)
+      expect(resource_list[0]).to be(resource)
+      expect(resource_list[1]).to be(second_resource)
+    end
+
+    it "should raise error when trying to install something other than Chef::Resource" do
+      expect{ resource_list.insert("not a resource") }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "accessors" do
+    it "should be able to insert with []=" do
+      expect{ resource_list[0] = resource }.not_to raise_error
+      expect{ resource_list[1] = second_resource }.not_to raise_error
+      expect(resource_list[0]).to be(resource)
+      expect(resource_list[1]).to be(second_resource)
+    end
+
+    it "should be empty by default" do
+      expect(resource_list.empty?).to be_true
+    end
+
+    describe "when resources are inserted" do
+      before do
+        insert_resource(resource)
+        insert_resource(second_resource)
+      end
+
+      it "should get resources with all_resources method" do
+        resources = resource_list.all_resources
+
+        expect(resources[0]).to be(resource)
+        expect(resources[1]).to be(second_resource)
+      end
+
+      it "should be able to get resources with each" do
+        current = 0
+        expected_resources = [resource, second_resource]
+
+        resource_list.each do |r|
+          expect(r).to be(expected_resources[current])
+          current += 1
+        end
+
+        expect(current).to eq(2)
+      end
+
+      it "should be able to get resources with each_index" do
+        current = 0
+
+        resource_list.each_index do |i|
+          expect(i).to eq(current)
+          current += 1
+        end
+
+        expect(current).to eq(2)
+      end
+
+      it "should be able to check if the list is empty" do
+        expect(resource_list.empty?).to be_false
+      end
+    end
+  end
+
+  describe "during execute" do
+    before(:each) do
+      insert_resource(resource)
+      insert_resource(second_resource)
+    end
+
+    it "should execute resources in order" do
+      current = 0
+      expected_resources = [resource, second_resource]
+
+      resource_list.execute_each_resource do |r|
+        expect(r).to be(expected_resources[current])
+        current += 1
+      end
+
+      expect(current).to eq(2)
+    end
+
+    it "should be able to insert resources on the fly" do
+      resource_to_inject = Chef::Resource::ZenMaster.new("there is no spoon")
+      expected_resources = [resource, resource_to_inject, second_resource]
+
+      resource_list.execute_each_resource do |r|
+        resource_list.insert(resource_to_inject) if r == resource
+      end
+
+      expect(resource_list.all_resources).to eq(expected_resources)
+    end
+  end
+end

data/spec/unit/resource_collection/resource_set_spec.rb

@@ -0,0 +1,199 @@
+#
+# Author:: Tyler Ball (<tball@getchef.com>)
+# 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'
+
+describe Chef::ResourceCollection::ResourceSet do
+  let(:collection) { Chef::ResourceCollection::ResourceSet.new }
+
+  let(:zen_master_name) { "Neo" }
+  let(:zen_master2_name) { "Morpheus" }
+  let(:zen_follower_name) { "Squid" }
+  let(:zen_master) { Chef::Resource::ZenMaster.new(zen_master_name) }
+  let(:zen_master2) { Chef::Resource::ZenMaster.new(zen_master2_name) }
+  let(:zen_follower) { Chef::Resource::ZenFollower.new(zen_follower_name) }
+
+  describe "initialize" do
+    it "should return a Chef::ResourceSet" do
+      expect(collection).to be_instance_of(Chef::ResourceCollection::ResourceSet)
+    end
+  end
+
+  describe "keys" do
+    it "should return an empty list for an empty ResourceSet" do
+      expect(collection.keys).to eq([])
+    end
+
+    it "should return the keys for a non-empty ResourceSet" do
+      collection.instance_variable_get(:@resources_by_key)["key"] = nil
+      expect(collection.keys).to eq(["key"])
+    end
+  end
+
+  describe "insert_as, lookup and find" do
+    # To validate insert_as you need lookup, and vice-versa - putting all tests in 1 context to avoid duplication
+    it "should accept only Chef::Resources" do
+      expect { collection.insert_as(zen_master) }.to_not raise_error
+      expect { collection.insert_as("string") }.to raise_error(ArgumentError)
+    end
+
+    it "should allow you to lookup resources by a default .to_s" do
+      collection.insert_as(zen_master)
+      expect(collection.lookup(zen_master.to_s)).to equal(zen_master)
+    end
+
+    it "should use a custom type and name to insert" do
+      collection.insert_as(zen_master, "OtherResource", "other_resource")
+      expect(collection.lookup("OtherResource[other_resource]")).to equal(zen_master)
+    end
+
+    it "should raise an exception if you send something strange to lookup" do
+      expect { collection.lookup(:symbol) }.to raise_error(ArgumentError)
+    end
+
+    it "should raise an exception if it cannot find a resource with lookup" do
+      expect { collection.lookup(zen_master.to_s) }.to raise_error(Chef::Exceptions::ResourceNotFound)
+    end
+
+    it "should find a resource by type symbol and name" do
+      collection.insert_as(zen_master)
+      expect(collection.find(:zen_master => zen_master_name)).to equal(zen_master)
+    end
+
+    it "should find a resource by type symbol and array of names" do
+      collection.insert_as(zen_master)
+      collection.insert_as(zen_master2)
+      check_by_names(collection.find(:zen_master => [zen_master_name,zen_master2_name]), zen_master_name, zen_master2_name)
+    end
+
+    it "should find a resource by type symbol and array of names with custom names" do
+      collection.insert_as(zen_master, :zzz, "name1")
+      collection.insert_as(zen_master2, :zzz, "name2")
+      check_by_names(collection.find( :zzz => ["name1","name2"]), zen_master_name, zen_master2_name)
+    end
+
+    it "should find resources of multiple kinds (:zen_master => a, :zen_follower => b)" do
+      collection.insert_as(zen_master)
+      collection.insert_as(zen_follower)
+      check_by_names(collection.find(:zen_master => [zen_master_name], :zen_follower => [zen_follower_name]),
+                     zen_master_name, zen_follower_name)
+    end
+
+    it "should find resources of multiple kinds (:zen_master => a, :zen_follower => b with custom names)" do
+      collection.insert_as(zen_master, :zzz, "name1")
+      collection.insert_as(zen_master2, :zzz, "name2")
+      collection.insert_as(zen_follower, :yyy, "name3")
+      check_by_names(collection.find(:zzz => ["name1","name2"], :yyy => ["name3"]),
+                     zen_master_name, zen_follower_name, zen_master2_name)
+    end
+
+    it "should find a resource by string zen_master[a]" do
+      collection.insert_as(zen_master)
+      expect(collection.find("zen_master[#{zen_master_name}]")).to eq(zen_master)
+    end
+
+    it "should find a resource by string zen_master[a] with custom names" do
+      collection.insert_as(zen_master, :zzz, "name1")
+      expect(collection.find("zzz[name1]")).to eq(zen_master)
+    end
+
+    it "should find resources by strings of zen_master[a,b]" do
+      collection.insert_as(zen_master)
+      collection.insert_as(zen_master2)
+      check_by_names(collection.find("zen_master[#{zen_master_name},#{zen_master2_name}]"),
+                     zen_master_name, zen_master2_name)
+    end
+
+    it "should find resources by strings of zen_master[a,b] with custom names" do
+      collection.insert_as(zen_master, :zzz, "name1")
+      collection.insert_as(zen_master2, :zzz, "name2")
+      check_by_names(collection.find("zzz[name1,name2]"),
+                     zen_master_name, zen_master2_name)
+    end
+
+    it "should find resources of multiple types by strings of zen_master[a]" do
+      collection.insert_as(zen_master)
+      collection.insert_as(zen_follower)
+      check_by_names(collection.find("zen_master[#{zen_master_name}]", "zen_follower[#{zen_follower_name}]"),
+                     zen_master_name, zen_follower_name)
+    end
+
+    it "should find resources of multiple types by strings of zen_master[a] with custom names" do
+      collection.insert_as(zen_master, :zzz, "name1")
+      collection.insert_as(zen_master2, :zzz, "name2")
+      collection.insert_as(zen_follower, :yyy, "name3")
+      check_by_names(collection.find("zzz[name1,name2]", "yyy[name3]"),
+                     zen_master_name, zen_follower_name,zen_master2_name)
+    end
+
+    it "should only keep the last copy when multiple instances of a Resource are inserted" do
+      collection.insert_as(zen_master)
+      expect(collection.find("zen_master[#{zen_master_name}]")).to eq(zen_master)
+      new_zm =zen_master.dup
+      new_zm.retries = 10
+      expect(new_zm).to_not eq(zen_master)
+      collection.insert_as(new_zm)
+      expect(collection.find("zen_master[#{zen_master_name}]")).to eq(new_zm)
+    end
+
+    it "should raise an exception if you pass a bad name to resources" do
+      expect { collection.find("michael jackson") }.to raise_error(ArgumentError)
+    end
+
+    it "should raise an exception if you pass something other than a string or hash to resource" do
+      expect { collection.find([Array.new]) }.to raise_error(ArgumentError)
+    end
+
+    it "raises an error when attempting to find a resource that does not exist" do
+      expect { collection.find("script[nonesuch]") }.to raise_error(Chef::Exceptions::ResourceNotFound)
+    end
+  end
+
+  describe "validate_lookup_spec!" do
+    it "accepts a string of the form 'resource_type[resource_name]'" do
+      expect(collection.validate_lookup_spec!("resource_type[resource_name]")).to be_true
+    end
+
+    it "accepts a single-element :resource_type => 'resource_name' Hash" do
+      expect(collection.validate_lookup_spec!(:service => "apache2")).to be_true
+    end
+
+    it "accepts a chef resource object" do
+      expect(collection.validate_lookup_spec!(zen_master)).to be_true
+    end
+
+    it "rejects a malformed query string" do
+      expect { collection.validate_lookup_spec!("resource_type[missing-end-bracket") }.to \
+        raise_error(Chef::Exceptions::InvalidResourceSpecification)
+    end
+
+    it "rejects an argument that is not a String, Hash, or Chef::Resource" do
+      expect { collection.validate_lookup_spec!(Object.new) }.to \
+        raise_error(Chef::Exceptions::InvalidResourceSpecification)
+    end
+
+  end
+
+  def check_by_names(results, *names)
+    expect(results.size).to eq(names.size)
+    names.each do |name|
+      expect(results.detect{|r| r.name == name}).to_not eq(nil)
+    end
+  end
+
+end