microwave 0.1006.33 → 1.0.0

data/spec/unit/resource_collection_spec.rb

@@ -0,0 +1,257 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2009 Opscode, 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 do
+  
+  before(:each) do
+    @rc = Chef::ResourceCollection.new()
+    @resource = Chef::Resource::ZenMaster.new("makoto")
+  end
+  
+  describe "initialize" do
+    it "should return a Chef::ResourceCollection" do
+      @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
+    end
+    
+    it "should allow you to fetch Chef::Resources by position" do
+      @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
+    end
+  end
+  
+  describe "<<" do
+    it "should accept the << operator" do
+      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
+    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)
+    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.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 "each" do
+    it "should allow you to iterate over every resource in the collection" do
+      load_up_resources
+      results = Array.new
+      lambda { 
+        @rc.each do |r|
+          results << r.name
+        end
+      }.should_not raise_error
+      results.each_index do |i|
+        case i
+        when 0
+          results[i].should eql("dog")
+        when 1
+          results[i].should eql("cat")
+        when 2
+          results[i].should eql("monkey")
+        end
+      end
+    end
+  end
+  
+  describe "each_index" do
+    it "should allow you to iterate over every resource by index" do
+      load_up_resources
+      results = Array.new
+      lambda { 
+        @rc.each_index do |i|
+          results << @rc[i].name
+        end 
+      }.should_not raise_error()
+      results.each_index do |i|
+        case i
+        when 0
+          results[i].should eql("dog")
+        when 1
+          results[i].should eql("cat")
+        when 2
+          results[i].should eql("monkey")
+        end
+      end
+    end
+  end
+  
+  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)
+
+      zmr = Chef::Resource::ZenMaster.new("cat")
+      @rc[0] = zmr
+      @rc.lookup(zmr).should eql(zmr)
+    
+      zmr = Chef::Resource::ZenMaster.new("monkey")
+      @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)
+    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)
+    end
+  end
+  
+  describe "resources" 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")
+    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.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.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")
+    end
+
+    it "should find resources by strings of zen_master[a,b]" do
+      load_up_resources
+      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.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)    
+    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)
+    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)
+    end
+
+  end
+  
+  describe "to_json" do
+    it "should serialize to json" do
+      json = @rc.to_json
+      json.should =~ /json_class/
+      json.should =~ /instance_vars/
+    end
+  end
+  
+  describe "self.from_json" do
+    it "should deserialize itself from json" do
+      @rc << @resource
+      json = @rc.to_json
+      s_rc = Chef::JSONCompat.from_json(json)
+      s_rc.should be_a_kind_of(Chef::ResourceCollection)
+      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))
+    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
+    end
+  end
+
+  def check_by_names(results, *names)
+    names.each do |res_name|
+      results.detect{ |res| res.name == res_name }.should_not eql(nil)
+    end
+  end
+  
+  def load_up_resources
+    %w{dog cat monkey}.each do |n|
+       @rc << Chef::Resource::ZenMaster.new(n)
+    end
+    @rc << Chef::Resource::File.new("something")
+  end
+    
+end

data/spec/unit/resource_definition_spec.rb

@@ -0,0 +1,119 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, 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::ResourceDefinition do
+  before(:each) do
+    @def = Chef::ResourceDefinition.new()
+  end
+  
+  describe "initialize" do
+    it "should be a Chef::ResourceDefinition" do
+      @def.should 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)
+    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"
+    end
+  end
+  
+  describe "node" do
+    it "should set the node with node=" do
+      node = Chef::Node.new
+      node.name("bobo")
+      @def.node = node
+      @def.node.name.should == "bobo"
+    end
+    
+    it "should return the node" do
+      @def.node = Chef::Node.new
+      @def.node.should 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 
+      end
+    }.should_not raise_error(ArgumentError)
+    lambda { 
+      @def.define "george washington" do
+      end 
+    }.should raise_error(ArgumentError)
+    @def.name.should eql(:smoke)
+  end
+  
+  it "should accept a new definition with a hash" do
+    lambda { 
+      @def.define :smoke, :cigar => "cuban", :cigarette => "marlboro" do
+      end
+    }.should_not raise_error(ArgumentError)
+  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")
+  end
+
+  it "should store the block passed to define as a proc under recipe" do
+    @def.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")
+  end
+  
+  it "should set paramaters based on method_missing" do
+    @def.mind "to fly"
+    @def.params[:mind].should eql("to fly")
+  end
+  
+  it "should raise an exception if prototype_params is not a hash" do
+    lambda {
+      @def.define :monkey, Array.new do
+      end
+    }.should 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)
+  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")
+  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")
+  end
+  
+end

data/spec/unit/resource_platform_map_spec.rb

@@ -0,0 +1,164 @@
+#
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, 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::Resource::PlatformMap do
+
+  before(:each) do
+    @platform_map = Chef::Resource::PlatformMap.new({
+      :windows => {
+        "6.1" => {
+          :file => "softiefile",
+          :else => "thing"
+        },
+        :default => {
+          :file => Chef::Resource::File,
+          :ping => "pong",
+          :cat => "nice"
+        }
+      },
+      :pop_tron => {
+      },
+      :default => {
+        :soundwave => "lazerbeak",
+        :directory => Chef::Resource::Directory,
+      }
+    })
+  end
+
+  describe 'filtering the map' do
+    it "returns resources for platform and version" do
+      pmap = @platform_map.filter("Windows", "6.1")
+      pmap.should be_a_kind_of(Hash)
+      pmap[:file].should eql("softiefile")
+    end
+
+    it "returns platform default resources if version does not exist" do
+      pmap = @platform_map.filter("windows", "1")
+      pmap.should be_a_kind_of(Hash)
+      pmap[:file].should eql(Chef::Resource::File)
+    end
+
+    it "returns global default resources if none exist for plaform" do
+      pmap = @platform_map.filter("pop_tron", "1")
+      pmap.should be_a_kind_of(Hash)
+      pmap[:directory].should eql(Chef::Resource::Directory)
+    end
+
+    it "returns global default resources if platform does not exist" do
+      pmap = @platform_map.filter("BeOS", "1")
+      pmap.should be_a_kind_of(Hash)
+      pmap[:soundwave].should eql("lazerbeak")
+    end
+
+    it "returns a merged map of platform version and plaform default resources" do
+      pmap = @platform_map.filter("Windows", "6.1")
+      pmap[:file].should eql("softiefile")
+      pmap[:ping].should eql("pong")
+    end
+
+    it "returns a merged map of platform specific version and global defaults" do
+      pmap = @platform_map.filter("Windows", "6.1")
+      pmap[:file].should eql("softiefile")
+      pmap[:soundwave].should eql("lazerbeak")
+    end
+  end
+
+  describe 'finding a resource' do
+    it "returns a resource for a platform directly by short name" do
+      @platform_map.get(:file, "windows", "6.1").should eql("softiefile")
+    end
+
+    it "returns a default resource if platform and version don't exist" do
+      @platform_map.get(:remote_file).should eql(Chef::Resource::RemoteFile)
+    end
+
+    it "raises an exception if a resource cannot be found" do
+      lambda { @platform_map.get(:coffee, "windows", "6.1")}.should raise_error(NameError)
+    end
+
+    it "returns a resource with a Chef::Resource object" do
+      kitty = Chef::Resource::Cat.new("loulou")
+      @platform_map.get(kitty, "windows", "6.1").should eql("nice")
+    end
+  end
+
+  describe 'building the map' do
+    it "allows passing of a resource map at creation time" do
+      @new_map = Chef::Resource::PlatformMap.new({:the_dude => {:default => 'abides'}})
+      @new_map.map[:the_dude][:default].should eql("abides")
+    end
+
+    it "defaults to a resource map with :default key" do
+      @new_map = Chef::Resource::PlatformMap.new
+      @new_map.map.has_key?(:default)
+    end
+
+    it "updates the resource map with a map" do
+      @platform_map.set(
+       :platform => :darwin,
+       :version => "9.2.2",
+       :short_name => :file,
+       :resource => "masterful"
+      )
+      @platform_map.map[:darwin]["9.2.2"][:file].should eql("masterful")
+
+      @platform_map.set(
+       :platform => :darwin,
+       :short_name => :file,
+       :resource => "masterful"
+      )
+      @platform_map.map[:darwin][:default][:file].should eql("masterful")
+
+      @platform_map.set(
+       :short_name => :file,
+       :resource => "masterful"
+      )
+      @platform_map.map[:default][:file].should eql("masterful")
+
+      @platform_map.set(
+       :platform => :hero,
+       :version => "9.2.2",
+       :short_name => :file,
+       :resource => "masterful"
+      )
+      @platform_map.map[:hero]["9.2.2"][:file].should eql("masterful")
+
+      @platform_map.set(
+        :short_name => :file,
+        :resource => "masterful"
+      )
+      @platform_map.map[:default][:file].should eql("masterful")
+
+      @platform_map.set(
+       :short_name => :file,
+       :resource => "masterful"
+      )
+      @platform_map.map[:default][:file].should eql("masterful")
+
+      @platform_map.set(
+        :platform => :neurosis,
+        :short_name => :package,
+        :resource => "masterful"
+      )
+      @platform_map.map[:neurosis][:default][:package].should eql("masterful")
+    end
+  end
+
+end