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

data/spec/unit/resource_collection_spec.rb

@@ -20,104 +20,77 @@
 require 'spec_helper'
 
 describe Chef::ResourceCollection do
+  let(:rc) { Chef::ResourceCollection.new() }
+  let(:resource) { Chef::Resource::ZenMaster.new("makoto") }
 
-  before(:each) do
-    @rc = Chef::ResourceCollection.new()
-    @resource = Chef::Resource::ZenMaster.new("makoto")
+  it "should throw an error when calling a non-delegated method" do
+    expect { rc.not_a_method }.to raise_error(NoMethodError)
   end
 
   describe "initialize" do
     it "should return a Chef::ResourceCollection" do
-      @rc.should be_kind_of(Chef::ResourceCollection)
+      rc.should be_kind_of(Chef::ResourceCollection)
     end
   end
 
   describe "[]" do
     it "should accept Chef::Resources through [index]" do
-      lambda { @rc[0] = @resource }.should_not raise_error
-      lambda { @rc[0] = "string" }.should raise_error
+      lambda { rc[0] = resource }.should_not raise_error
+      lambda { rc[0] = "string" }.should raise_error(ArgumentError)
     end
 
     it "should allow you to fetch Chef::Resources by position" do
-      @rc[0] = @resource
-      @rc[0].should eql(@resource)
+      rc[0] = resource
+      rc[0].should eql(resource)
     end
   end
 
   describe "push" do
     it "should accept Chef::Resources through pushing" do
-      lambda { @rc.push(@resource) }.should_not raise_error
-      lambda { @rc.push("string") }.should raise_error
+      lambda { rc.push(resource) }.should_not raise_error
+      lambda { rc.push("string") }.should raise_error(ArgumentError)
     end
   end
 
   describe "<<" do
     it "should accept the << operator" do
-      lambda { @rc << @resource }.should_not raise_error
+      lambda { rc << resource }.should_not raise_error
     end
   end
 
   describe "insert" do
     it "should accept only Chef::Resources" do
-      lambda { @rc.insert(@resource) }.should_not raise_error
-      lambda { @rc.insert("string") }.should raise_error
+      lambda { rc.insert(resource) }.should_not raise_error
+      lambda { rc.insert("string") }.should raise_error(ArgumentError)
+    end
+
+    it "should accept named arguments in any order" do
+      rc.insert(resource, :instance_name => 'foo', :resource_type =>'bar')
+      expect(rc[0]).to eq(resource)
     end
 
     it "should append resources to the end of the collection when not executing a run" do
       zmr = Chef::Resource::ZenMaster.new("there is no spoon")
-      @rc.insert(@resource)
-      @rc.insert(zmr)
-      @rc[0].should eql(@resource)
-      @rc[1].should eql(zmr)
+      rc.insert(resource)
+      rc.insert(zmr)
+      rc[0].should eql(resource)
+      rc[1].should eql(zmr)
     end
 
     it "should insert resources to the middle of the collection if called while executing a run" do
       resource_to_inject = Chef::Resource::ZenMaster.new("there is no spoon")
       zmr = Chef::Resource::ZenMaster.new("morpheus")
       dummy = Chef::Resource::ZenMaster.new("keanu reeves")
-      @rc.insert(zmr)
-      @rc.insert(dummy)
+      rc.insert(zmr)
+      rc.insert(dummy)
 
-      @rc.execute_each_resource do |resource|
-        @rc.insert(resource_to_inject) if resource == zmr
+      rc.execute_each_resource do |resource|
+        rc.insert(resource_to_inject) if resource == zmr
       end
 
-      @rc[0].should eql(zmr)
-      @rc[1].should eql(resource_to_inject)
-      @rc[2].should eql(dummy)
-    end
-  end
-
-  describe "insert_at" do
-    it "should accept only Chef::Resources" do
-      lambda { @rc.insert_at(0, @resource, @resource) }.should_not raise_error
-      lambda { @rc.insert_at(0, "string") }.should raise_error
-      lambda { @rc.insert_at(0, @resource, "string") }.should raise_error
-    end
-
-    it "should toss an error if it receives a bad index" do
-      @rc.insert_at(10, @resource)
-    end
-
-    it "should insert resources at the beginning when asked" do
-      @rc.insert(Chef::Resource::ZenMaster.new('1'))
-      @rc.insert(Chef::Resource::ZenMaster.new('2'))
-      @rc.insert_at(0, Chef::Resource::ZenMaster.new('X'))
-      @rc.all_resources.map { |r| r.name }.should == [ 'X', '1', '2' ]
-    end
-
-    it "should insert resources in the middle when asked" do
-      @rc.insert(Chef::Resource::ZenMaster.new('1'))
-      @rc.insert(Chef::Resource::ZenMaster.new('2'))
-      @rc.insert_at(1, Chef::Resource::ZenMaster.new('X'))
-      @rc.all_resources.map { |r| r.name }.should == [ '1', 'X', '2' ]
-    end
-
-    it "should insert resources at the end when asked" do
-      @rc.insert(Chef::Resource::ZenMaster.new('1'))
-      @rc.insert(Chef::Resource::ZenMaster.new('2'))
-      @rc.insert_at(2, Chef::Resource::ZenMaster.new('X'))
-      @rc.all_resources.map { |r| r.name }.should == [ '1', '2', 'X' ]
+      rc[0].should eql(zmr)
+      rc[1].should eql(resource_to_inject)
+      rc[2].should eql(dummy)
     end
   end
 
@@ -126,7 +99,7 @@ describe Chef::ResourceCollection do
       load_up_resources
       results = Array.new
       lambda {
-        @rc.each do |r|
+        rc.each do |r|
           results << r.name
         end
       }.should_not raise_error
@@ -148,8 +121,8 @@ describe Chef::ResourceCollection do
       load_up_resources
       results = Array.new
       lambda {
-        @rc.each_index do |i|
-          results << @rc[i].name
+        rc.each_index do |i|
+          results << rc[i].name
         end
       }.should_not raise_error
       results.each_index do |i|
@@ -168,24 +141,24 @@ describe Chef::ResourceCollection do
   describe "lookup" do
     it "should allow you to find resources by name via lookup" do
       zmr = Chef::Resource::ZenMaster.new("dog")
-      @rc << zmr
-      @rc.lookup(zmr.to_s).should eql(zmr)
+      rc << zmr
+      rc.lookup(zmr.to_s).should eql(zmr)
 
       zmr = Chef::Resource::ZenMaster.new("cat")
-      @rc[0] = zmr
-      @rc.lookup(zmr).should eql(zmr)
+      rc[0] = zmr
+      rc.lookup(zmr).should eql(zmr)
 
       zmr = Chef::Resource::ZenMaster.new("monkey")
-      @rc.push(zmr)
-      @rc.lookup(zmr).should eql(zmr)
+      rc.push(zmr)
+      rc.lookup(zmr).should eql(zmr)
     end
 
     it "should raise an exception if you send something strange to lookup" do
-      lambda { @rc.lookup(:symbol) }.should raise_error(ArgumentError)
+      lambda { rc.lookup(:symbol) }.should raise_error(ArgumentError)
     end
 
     it "should raise an exception if it cannot find a resource with lookup" do
-      lambda { @rc.lookup("zen_master[dog]") }.should raise_error(Chef::Exceptions::ResourceNotFound)
+      lambda { rc.lookup("zen_master[dog]") }.should raise_error(Chef::Exceptions::ResourceNotFound)
     end
   end
 
@@ -193,80 +166,80 @@ describe Chef::ResourceCollection do
 
     it "should find a resource by symbol and name (:zen_master => monkey)" do
       load_up_resources
-      @rc.resources(:zen_master => "monkey").name.should eql("monkey")
+      rc.resources(:zen_master => "monkey").name.should eql("monkey")
     end
 
     it "should find a resource by symbol and array of names (:zen_master => [a,b])" do
       load_up_resources
-      results = @rc.resources(:zen_master => [ "monkey", "dog" ])
+      results = rc.resources(:zen_master => [ "monkey", "dog" ])
       results.length.should eql(2)
       check_by_names(results, "monkey", "dog")
     end
 
     it "should find resources of multiple kinds (:zen_master => a, :file => b)" do
       load_up_resources
-      results = @rc.resources(:zen_master => "monkey", :file => "something")
+      results = rc.resources(:zen_master => "monkey", :file => "something")
       results.length.should eql(2)
       check_by_names(results, "monkey", "something")
     end
 
     it "should find a resource by string zen_master[a]" do
       load_up_resources
-      @rc.resources("zen_master[monkey]").name.should eql("monkey")
+      rc.resources("zen_master[monkey]").name.should eql("monkey")
     end
 
     it "should find resources by strings of zen_master[a,b]" do
       load_up_resources
-      results = @rc.resources("zen_master[monkey,dog]")
+      results = rc.resources("zen_master[monkey,dog]")
       results.length.should eql(2)
       check_by_names(results, "monkey", "dog")
     end
 
     it "should find resources of multiple types by strings of zen_master[a]" do
       load_up_resources
-      results = @rc.resources("zen_master[monkey]", "file[something]")
+      results = rc.resources("zen_master[monkey]", "file[something]")
       results.length.should eql(2)
       check_by_names(results, "monkey", "something")
     end
 
     it "should raise an exception if you pass a bad name to resources" do
-      lambda { @rc.resources("michael jackson") }.should raise_error(ArgumentError)
+      lambda { rc.resources("michael jackson") }.should raise_error(ArgumentError)
     end
 
     it "should raise an exception if you pass something other than a string or hash to resource" do
-      lambda { @rc.resources([Array.new]) }.should raise_error(ArgumentError)
+      lambda { rc.resources([Array.new]) }.should raise_error(ArgumentError)
     end
 
     it "raises an error when attempting to find a resource that does not exist" do
-      lambda {@rc.find("script[nonesuch]")}.should raise_error(Chef::Exceptions::ResourceNotFound)
+      lambda {rc.find("script[nonesuch]")}.should raise_error(Chef::Exceptions::ResourceNotFound)
     end
 
   end
 
   describe "when validating a resource query object" do
     it "accepts a string of the form 'resource_type[resource_name]'" do
-      @rc.validate_lookup_spec!("resource_type[resource_name]").should be_true
+      rc.validate_lookup_spec!("resource_type[resource_name]").should be_true
     end
 
     it "accepts a single-element :resource_type => 'resource_name' Hash" do
-      @rc.validate_lookup_spec!(:service => "apache2").should be_true
+      rc.validate_lookup_spec!(:service => "apache2").should be_true
     end
 
 
     it "accepts a chef resource object" do
       res = Chef::Resource.new("foo", nil)
-      @rc.validate_lookup_spec!(res).should be_true
+      rc.validate_lookup_spec!(res).should be_true
     end
 
     it "rejects a malformed query string" do
       lambda do
-        @rc.validate_lookup_spec!("resource_type[missing-end-bracket")
+        rc.validate_lookup_spec!("resource_type[missing-end-bracket")
       end.should raise_error(Chef::Exceptions::InvalidResourceSpecification)
     end
 
     it "rejects an argument that is not a String, Hash, or Chef::Resource" do
       lambda do
-        @rc.validate_lookup_spec!(Object.new)
+        rc.validate_lookup_spec!(Object.new)
       end.should raise_error(Chef::Exceptions::InvalidResourceSpecification)
     end
 
@@ -274,32 +247,40 @@ describe Chef::ResourceCollection do
 
   describe "to_json" do
     it "should serialize to json" do
-      json = @rc.to_json
+      json = rc.to_json
       json.should =~ /json_class/
       json.should =~ /instance_vars/
     end
+
+    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+      let(:jsonable) { rc }
+    end
   end
 
   describe "self.from_json" do
-    it "should deserialize itself from json" do
-      @rc << @resource
-      json = @rc.to_json
+    it "should not respond to this method" do
+      expect(rc.respond_to?(:from_json)).to eq(false)
+    end
+
+    it "should convert from json using the CHEF::JSONCompat library" do
+      rc << resource
+      json = Chef::JSONCompat.to_json(rc)
       s_rc = Chef::JSONCompat.from_json(json)
       s_rc.should be_a_kind_of(Chef::ResourceCollection)
-      s_rc[0].name.should eql(@resource.name)
+      s_rc[0].name.should eql(resource.name)
     end
   end
 
   describe "provides access to the raw resources array" do
     it "returns the resources via the all_resources method" do
-      @rc.all_resources.should equal(@rc.instance_variable_get(:@resources))
+      rc.all_resources.should equal(rc.instance_variable_get(:@resource_list).instance_variable_get(:@resources))
     end
   end
 
   describe "provides access to stepable iterator" do
     it "returns the iterator object" do
-      @rc.instance_variable_set(:@iterator, :fooboar)
-      @rc.iterator.should == :fooboar
+      rc.instance_variable_get(:@resource_list).instance_variable_set(:@iterator, :fooboar)
+      rc.iterator.should == :fooboar
     end
   end
 
@@ -311,9 +292,9 @@ describe Chef::ResourceCollection do
 
   def load_up_resources
     %w{dog cat monkey}.each do |n|
-       @rc << Chef::Resource::ZenMaster.new(n)
+       rc << Chef::Resource::ZenMaster.new(n)
     end
-    @rc << Chef::Resource::File.new("something")
+    rc << Chef::Resource::File.new("something")
   end
 
 end

data/spec/unit/resource_definition_spec.rb

@@ -19,24 +19,22 @@
 require 'spec_helper'
 
 describe Chef::ResourceDefinition do
-  before(:each) do
-    @def = Chef::ResourceDefinition.new()
-  end
+  let(:defn) { Chef::ResourceDefinition.new() }
 
   describe "initialize" do
     it "should be a Chef::ResourceDefinition" do
-      @def.should be_a_kind_of(Chef::ResourceDefinition)
+      expect(defn).to be_a_kind_of(Chef::ResourceDefinition)
     end
 
     it "should not initialize a new node if one is not provided" do
-      @def.node.should eql(nil)
+      expect(defn.node).to eql(nil)
     end
 
     it "should accept a node as an argument" do
       node = Chef::Node.new
       node.name("bobo")
-      @def = Chef::ResourceDefinition.new(node)
-      @def.node.name.should == "bobo"
+      defn = Chef::ResourceDefinition.new(node)
+      expect(defn.node.name).to eq("bobo")
     end
   end
 
@@ -44,76 +42,76 @@ describe Chef::ResourceDefinition do
     it "should set the node with node=" do
       node = Chef::Node.new
       node.name("bobo")
-      @def.node = node
-      @def.node.name.should == "bobo"
+      defn.node = node
+      expect(defn.node.name).to eq("bobo")
     end
 
     it "should return the node" do
-      @def.node = Chef::Node.new
-      @def.node.should be_a_kind_of(Chef::Node)
+      defn.node = Chef::Node.new
+      expect(defn.node).to be_a_kind_of(Chef::Node)
     end
   end
 
   it "should accept a new definition with a symbol for a name" do
-    lambda {
-      @def.define :smoke do
+    expect {
+      defn.define :smoke do
       end
-    }.should_not raise_error
-    lambda {
-      @def.define "george washington" do
+    }.not_to raise_error
+    expect {
+      defn.define "george washington" do
       end
-    }.should raise_error(ArgumentError)
-    @def.name.should eql(:smoke)
+    }.to raise_error(ArgumentError)
+    expect(defn.name).to eql(:smoke)
   end
 
   it "should accept a new definition with a hash" do
-    lambda {
-      @def.define :smoke, :cigar => "cuban", :cigarette => "marlboro" do
+    expect {
+      defn.define :smoke, :cigar => "cuban", :cigarette => "marlboro" do
       end
-    }.should_not raise_error
+    }.not_to raise_error
   end
 
   it "should expose the prototype hash params in the params hash" do
-    @def.define :smoke, :cigar => "cuban", :cigarette => "marlboro" do; end
-    @def.params[:cigar].should eql("cuban")
-    @def.params[:cigarette].should eql("marlboro")
+    defn.define :smoke, :cigar => "cuban", :cigarette => "marlboro" do; end
+    expect(defn.params[:cigar]).to eql("cuban")
+    expect(defn.params[:cigarette]).to eql("marlboro")
   end
 
   it "should store the block passed to define as a proc under recipe" do
-    @def.define :smoke do
+    defn.define :smoke do
       "I am what I am"
     end
-    @def.recipe.should be_a_kind_of(Proc)
-    @def.recipe.call.should eql("I am what I am")
+    expect(defn.recipe).to be_a_kind_of(Proc)
+    expect(defn.recipe.call).to eql("I am what I am")
   end
 
   it "should set paramaters based on method_missing" do
-    @def.mind "to fly"
-    @def.params[:mind].should eql("to fly")
+    defn.mind "to fly"
+    expect(defn.params[:mind]).to eql("to fly")
   end
 
   it "should raise an exception if prototype_params is not a hash" do
-    lambda {
-      @def.define :monkey, Array.new do
+    expect {
+      defn.define :monkey, Array.new do
       end
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   it "should raise an exception if define is called without a block" do
-    lambda {
-      @def.define :monkey
-    }.should raise_error(ArgumentError)
+    expect {
+      defn.define :monkey
+    }.to raise_error(ArgumentError)
   end
 
   it "should load a description from a file" do
-    @def.from_file(File.join(CHEF_SPEC_DATA, "definitions", "test.rb"))
-    @def.name.should eql(:rico_suave)
-    @def.params[:rich].should eql("smooth")
+    defn.from_file(File.join(CHEF_SPEC_DATA, "definitions", "test.rb"))
+    expect(defn.name).to eql(:rico_suave)
+    expect(defn.params[:rich]).to eql("smooth")
   end
 
   it "should turn itself into a string based on the name with to_s" do
-    @def.name = :woot
-    @def.to_s.should eql("woot")
+    defn.name = :woot
+    expect(defn.to_s).to eql("woot")
   end
 
 end