chef 10.34.6 → 11.0.0.beta.0

data/spec/unit/daemon_spec.rb

@@ -150,32 +150,11 @@ describe Chef::Daemon do
         File.stub!(:exists?).with("/var/run/chef/chef-client.pid").and_return(true)
       end
 
-      describe "and contains the current pid" do
-
-        before do
-          File.stub!(:read).with("/var/run/chef/chef-client.pid").and_return("#$$\n")
-        end
-
-        it "should remove the file" do
-          FileUtils.should_receive(:rm).with("/var/run/chef/chef-client.pid")
-          Chef::Daemon.remove_pid_file
-        end
-
+      it "should remove the file" do
+        FileUtils.should_receive(:rm).with("/var/run/chef/chef-client.pid")
+        Chef::Daemon.remove_pid_file
       end
 
-      describe "and contains a different pid" do
-
-        before do
-          other_pid = Process.pid + 1
-          File.stub!(:read).with("/var/run/chef/chef-client.pid").and_return("#{other_pid}\n")
-        end
-
-        it "should not remove the file" do
-          FileUtils.should_not_receive(:rm)
-          Chef::Daemon.remove_pid_file
-        end
-
-      end
 
     end
 

data/spec/unit/data_bag_spec.rb

@@ -76,13 +76,14 @@ describe Chef::DataBag do
       Chef::REST.stub!(:new).and_return(@rest)
     end
 
-    it "should silently proceed when the data bag already exists" do
-      exception = mock("409 error", :code => "409")
-      @rest.should_receive(:post_rest).and_raise(Net::HTTPServerException.new("foo", exception))
+    it "should update the data bag when it already exists" do
+      @rest.should_receive(:put_rest).with("data/piggly_wiggly", @data_bag) 
       @data_bag.save
     end
 
-    it "should create the data bag" do
+    it "should create the data bag when it is not found" do 
+      exception = mock("404 error", :code => "404")
+      @rest.should_receive(:put_rest).and_raise(Net::HTTPServerException.new("foo", exception))
       @rest.should_receive(:post_rest).with("data", @data_bag)
       @data_bag.save
     end 
@@ -95,6 +96,7 @@ describe Chef::DataBag do
         Chef::Config[:why_run] = false
       end
       it "should not save" do
+        @rest.should_not_receive(:put_rest)
         @rest.should_not_receive(:post_rest)
         @data_bag.save
       end

data/spec/unit/digester_spec.rb

@@ -0,0 +1,50 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2009 Opscode, Inc.
+# Copyright:: Copyright (c) 2009 Daniel DeLeo
+# 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::Digester do
+  before(:each) do
+    @cache = Chef::Digester.instance
+  end
+
+  describe "when computing checksums of cookbook files and templates" do
+
+    it "proxies the class method checksum_for_file to the instance" do
+      @cache.should_receive(:checksum_for_file).with("a_file_or_a_fail")
+      Chef::Digester.checksum_for_file("a_file_or_a_fail")
+    end
+
+    it "computes a checksum of a file" do
+      fixture_file = CHEF_SPEC_DATA + "/checksum/random.txt"
+      expected = "09ee9c8cc70501763563bcf9c218d71b2fbf4186bf8e1e0da07f0f42c80a3394"
+      @cache.checksum_for_file(fixture_file).should == expected
+    end
+
+    it "generates a checksum from a non-file IO object" do
+      io = StringIO.new("riseofthemachines\nriseofthechefs\n")
+      expected_md5 = '0e157ac1e2dd73191b76067fb6b4bceb'
+      @cache.generate_md5_checksum(io).should == expected_md5
+    end
+
+  end
+
+end
+

data/spec/unit/dsl/data_query_spec.rb

@@ -0,0 +1,66 @@
+#
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright (c) 2010 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'
+require 'chef/dsl/data_query'
+
+class DataQueryDSLTester
+  include Chef::DSL::DataQuery
+end
+
+describe Chef::DSL::DataQuery do
+  before(:each) do
+    @language = DataQueryDSLTester.new
+    @node = Hash.new
+    @language.stub!(:node).and_return(@node)
+  end
+
+  describe "when loading data bags and items" do
+    it "lists the items in a data bag" do
+      Chef::DataBag.should_receive(:load).with("bag_name").and_return("item_1" => "http://url_for/item_1", "item_2" => "http://url_for/item_2")
+      @language.data_bag("bag_name").sort.should == %w[item_1 item_2]
+    end
+
+    it "validates the name of the data bag you're trying to load" do
+      lambda {@language.data_bag("!# %^&& ")}.should raise_error(Chef::Exceptions::InvalidDataBagName)
+    end
+
+    it "fetches a data bag item" do
+      @item = Chef::DataBagItem.new
+      @item.data_bag("bag_name")
+      @item.raw_data = {"id" => "item_name", "FUU" => "FUU"}
+      Chef::DataBagItem.should_receive(:load).with("bag_name", "item_name").and_return(@item)
+      @language.data_bag_item("bag_name", "item_name").should == @item
+    end
+
+    it "validates the name of the data bag you're trying to load an item from" do
+      lambda {@language.data_bag_item(" %%^& ", "item_name")}.should raise_error(Chef::Exceptions::InvalidDataBagName)
+    end
+
+    it "validates the id of the data bag item you're trying to load" do
+      lambda {@language.data_bag_item("bag_name", " 987 (*&()")}.should raise_error(Chef::Exceptions::InvalidDataBagItemID)
+    end
+
+    it "validates that the id of the data bag item is not nil" do
+      lambda {@language.data_bag_item("bag_name", nil)}.should raise_error(Chef::Exceptions::InvalidDataBagItemID)
+    end
+
+  end
+
+end
+

data/spec/unit/dsl/platform_introspection_spec.rb

@@ -0,0 +1,130 @@
+#
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright (c) 2010 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'
+require 'chef/dsl/platform_introspection'
+
+class LanguageTester
+  attr_reader :node
+  def initialize(node)
+    @node = node
+  end
+  include Chef::DSL::PlatformIntrospection
+end
+
+describe "PlatformIntrospection implementors" do
+
+  let(:node) { Chef::Node.new }
+  let(:platform_introspector) { LanguageTester.new(node) }
+
+  it_behaves_like "a platform introspector"
+
+end
+
+describe Chef::DSL::PlatformIntrospection::PlatformDependentValue do
+  before do
+    platform_hash = {
+      :openbsd => {:default => 'free, functional, secure'},
+      [:redhat, :centos, :fedora, :scientific] => {:default => '"stable"'},
+      :ubuntu => {'10.04' => 'using upstart more', :default => 'using init more'},
+      :default => 'bork da bork'
+    }
+    @platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformDependentValue.new(platform_hash)
+  end
+
+  it "returns the default value when the platform doesn't match" do
+    @platform_specific_value.value_for_node(:platform => :dos).should == 'bork da bork'
+  end
+
+  it "returns a value for a platform set as a group" do
+    @platform_specific_value.value_for_node(:platform => :centos).should == '"stable"'
+  end
+
+  it "returns a value for the platform when it was set as a symbol but fetched as a string" do
+    @platform_specific_value.value_for_node(:platform => "centos").should == '"stable"'
+  end
+
+  it "returns a value for a specific platform version" do
+    node = {:platform => 'ubuntu', :platform_version => '10.04'}
+    @platform_specific_value.value_for_node(node).should == 'using upstart more'
+  end
+
+  it "returns a platform-default value if the platform version doesn't match an explicit one" do
+    node = {:platform => 'ubuntu', :platform_version => '9.10' }
+    @platform_specific_value.value_for_node(node).should == 'using init more'
+  end
+
+  it "returns nil if there is no default and no platforms match" do
+    # this matches the behavior in the original implementation.
+    # whether or not it's correct is another matter.
+    platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformDependentValue.new({})
+    platform_specific_value.value_for_node(:platform => 'foo').should be_nil
+  end
+
+  it "raises an argument error if the platform hash is not correctly structured" do
+    bad_hash = {:ubuntu => :foo} # should be :ubuntu => {:default => 'foo'}
+    lambda {Chef::DSL::PlatformIntrospection::PlatformDependentValue.new(bad_hash)}.should raise_error(ArgumentError)
+  end
+
+end
+describe Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue do
+  before do
+    @array_values = [:stop, :start, :reload]
+
+    @platform_family_hash = {
+      "debian" => "debian value",
+      [:rhel, "fedora"] => "redhatty value",
+      "suse" => @array_values,
+      :gentoo => "gentoo value",
+      :default => "default value"
+    }
+
+    @platform_family_value = Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue.new(@platform_family_hash)
+  end
+
+  it "returns the default value when the platform family doesn't match" do
+    @platform_family_value.value_for_node(:platform_family => :os2).should == 'default value'
+  end
+
+
+  it "returns a value for the platform family when it was set as a string but fetched as a symbol" do
+    @platform_family_value.value_for_node(:platform_family => :debian).should == "debian value"
+  end
+
+  it "returns a value for the platform family when it was set as a symbol but fetched as a string" do
+    @platform_family_value.value_for_node(:platform_family => "gentoo").should == "gentoo value"
+  end
+
+  it "returns an array value stored for a platform family" do
+    @platform_family_value.value_for_node(:platform_family => "suse").should == @array_values
+  end
+
+  it "returns a value for the platform family when it was set within an array hash key as a symbol" do
+    @platform_family_value.value_for_node(:platform_family => :rhel).should == "redhatty value"
+  end
+
+  it "returns a value for the platform family when it was set within an array hash key as a string" do
+    @platform_family_value.value_for_node(:platform_family => "fedora").should == "redhatty value"
+  end
+
+  it "returns nil if there is no default and no platforms match" do
+    platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue.new({})
+    platform_specific_value.value_for_node(:platform_family => 'foo').should be_nil
+  end
+
+end

data/spec/unit/dsl/regsitry_helper_spec.rb

@@ -0,0 +1,55 @@
+#
+# Author:: Prajakta Purohit (<prajakta@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 "chef/dsl/registry_helper"
+require "spec_helper"
+
+describe Chef::Resource::RegistryKey do
+
+  before (:all) do
+    events = Chef::EventDispatch::Dispatcher.new
+    node = Chef::Node.new
+    ohai = Ohai::System.new
+    ohai.all_plugins
+    node.consume_external_attrs(ohai.data,{})
+    run_context = Chef::RunContext.new(node, {}, events)
+    @resource = Chef::Resource::new("foo", run_context)
+  end
+
+  context "tests registry dsl" do
+    it "resource can access registry_helper method registry_key_exists" do
+      @resource.respond_to?('registry_key_exists?').should == true
+    end
+    it "resource can access registry_helper method registry_get_values" do
+      @resource.respond_to?('registry_get_values').should == true
+    end
+    it "resource can access registry_helper method registry_has_subkey" do
+      @resource.respond_to?('registry_has_subkeys?').should == true
+    end
+    it "resource can access registry_helper method registry_get_subkeys" do
+      @resource.respond_to?('registry_get_subkeys').should == true
+    end
+    it "resource can access registry_helper method registry_value_exists" do
+      @resource.respond_to?('registry_value_exists?').should == true
+    end
+    it "resource can access registry_helper method data_value_exists" do
+      @resource.respond_to?('registry_data_exists?').should == true
+    end
+  end
+end
+

data/spec/unit/encrypted_data_bag_item_spec.rb

@@ -19,7 +19,7 @@
 require 'spec_helper'
 require 'chef/encrypted_data_bag_item'
 
-module Version0Encryptor
+module Version1Encryptor
   def self.encrypt_value(plaintext_data, key)
     data = plaintext_data.to_yaml
 
@@ -32,83 +32,46 @@ module Version0Encryptor
   end
 end
 
-# Encryption/serialization code from Chef 11.
-class Version1Encryptor
-  ALGORITHM = "aes-256-cbc"
-
-  attr_reader :key
-  attr_reader :plaintext_data
-
-  # Create a new Encryptor for +data+, which will be encrypted with the given
-  # +key+.
-  #
-  # === Arguments:
-  # * data: An object of any type that can be serialized to json
-  # * key: A String representing the desired passphrase
-  # * iv: The optional +iv+ parameter is intended for testing use only. When
-  # *not* supplied, Encryptor will use OpenSSL to generate a secure random
-  # IV, which is what you want.
-  def initialize(plaintext_data, key, iv=nil)
-    @plaintext_data = plaintext_data
-    @key = key
-    @iv = iv && Base64.decode64(iv)
-  end
+describe Chef::EncryptedDataBagItem::Encryptor  do
 
-  # Returns a wrapped and encrypted version of +plaintext_data+ suitable for
-  # using as the value in an encrypted data bag item.
-  def for_encrypted_item
-    {
-      "encrypted_data" => encrypted_data,
-      "iv" => Base64.encode64(iv),
-      "version" => 1,
-      "cipher" => ALGORITHM
-    }
-  end
+  describe "generating a random IV" do
+    it "generates a new IV for each encryption pass" do
+      encryptor1 = Chef::EncryptedDataBagItem::Encryptor.new({"foo" => "bar"}, "passwd")
+      encryptor2 = Chef::EncryptedDataBagItem::Encryptor.new({"foo" => "bar"}, "passwd")
 
-  # Generates or returns the IV.
-  def iv
-    # Generated IV comes from OpenSSL::Cipher::Cipher#random_iv
-    # This gets generated when +openssl_encryptor+ gets created.
-    openssl_encryptor if @iv.nil?
-    @iv
+      # No API in ruby OpenSSL to get the iv it used for the encryption back
+      # out. Instead we test if the encrypted data is the same. If it *is* the
+      # same, we assume the IV was the same each time.
+      encryptor1.encrypted_data.should_not == encryptor2.encrypted_data
+    end
   end
 
-  # Generates (and memoizes) an OpenSSL::Cipher::Cipher object and configures
-  # it for the specified iv and encryption key.
-  def openssl_encryptor
-    @openssl_encryptor ||= begin
-      encryptor = OpenSSL::Cipher::Cipher.new(ALGORITHM)
-      encryptor.encrypt
-      @iv ||= encryptor.random_iv
-      encryptor.iv = @iv
-      encryptor.key = Digest::SHA256.digest(key)
-      encryptor
+  describe "when encrypting a non-hash non-array value" do
+    it "serializes the value in a de-serializable way" do
+      encryptor = Chef::EncryptedDataBagItem::Encryptor.new(5, "passwd")
+      Chef::JSONCompat.from_json(encryptor.serialized_data)["json_wrapper"].should == 5
     end
+
   end
 
-  # Encrypts and Base64 encodes +serialized_data+
-  def encrypted_data
-    @encrypted_data ||= begin
-      enc_data = openssl_encryptor.update(serialized_data)
-      enc_data << openssl_encryptor.final
-      Base64.encode64(enc_data)
+  describe "wrapping secret values in an envelope" do
+    it "wraps the encrypted data in an envelope with the iv and version" do
+      encryptor = Chef::EncryptedDataBagItem::Encryptor.new({"foo" => "bar"}, "passwd")
+      final_data = encryptor.for_encrypted_item
+      final_data["encrypted_data"].should == encryptor.encrypted_data
+      final_data["iv"].should == Base64.encode64(encryptor.iv)
+      final_data["version"].should == 1
+      final_data["cipher"].should == "aes-256-cbc"
     end
-  end
 
-  # Wraps the data in a single key Hash (JSON Object) and converts to JSON.
-  # The wrapper is required because we accept values (such as Integers or
-  # Strings) that do not produce valid JSON when serialized without the
-  # wrapper.
-  def serialized_data
-    Chef::JSONCompat.to_json(:json_wrapper => plaintext_data)
   end
-end
 
+end
 
 describe Chef::EncryptedDataBagItem::Decryptor do
   context "when decrypting a version 1 (JSON+aes-256-cbc+random iv) encrypted value" do
     before do
-      @encryptor = Version1Encryptor.new({"foo" => "bar"}, "passwd")
+      @encryptor = Chef::EncryptedDataBagItem::Encryptor.new({"foo" => "bar"}, "passwd")
       @encrypted_value = @encryptor.for_encrypted_item
 
       @decryptor = Chef::EncryptedDataBagItem::Decryptor.for(@encrypted_value, "passwd")
@@ -150,7 +113,7 @@ describe Chef::EncryptedDataBagItem::Decryptor do
 
   context "when decrypting a version 0 (YAML+aes-256-cbc+no iv) encrypted value" do
     before do
-      @encrypted_value = Version0Encryptor.encrypt_value({"foo" => "bar"}, "passwd")
+      @encrypted_value = Version1Encryptor.encrypt_value({"foo" => "bar"}, "passwd")
 
       @decryptor = Chef::EncryptedDataBagItem::Decryptor.for(@encrypted_value, "passwd")
     end
@@ -177,33 +140,41 @@ describe Chef::EncryptedDataBagItem do
                                                                  @secret)
   end
 
-  describe "encrypting" do
 
-    it "uses version 0 encryption/serialization" do
-      @enc_data["greeting"].should == Version0Encryptor.encrypt_value(@plain_data["greeting"], @secret)
-    end
+  describe "encrypting" do
 
     it "should not encrypt the 'id' key" do
       @enc_data["id"].should == "item_name"
     end
 
-    it "should encrypt 'greeting'" do
-      @enc_data["greeting"].should_not == @plain_data["greeting"]
-    end
+    it "should encrypt non-collection objects" do
+      @enc_data["greeting"]["version"].should == 1
+      @enc_data["greeting"].should have_key("iv")
+
+      iv = @enc_data["greeting"]["iv"]
+      encryptor = Chef::EncryptedDataBagItem::Encryptor.new("hello", @secret, iv)
 
-    it "should encrypt 'nested'" do
-      nested = @enc_data["nested"]
-      nested.class.should == String
-      nested.should_not == @plain_data["nested"]
+      @enc_data["greeting"]["encrypted_data"].should == encryptor.for_encrypted_item["encrypted_data"]
     end
 
-    it "from_plain_hash" do
-      eh1 = Chef::EncryptedDataBagItem.from_plain_hash(@plain_data, @secret)
-      eh1.class.should == Chef::EncryptedDataBagItem
+    it "should encrypt nested values" do
+      @enc_data["nested"]["version"].should == 1
+      @enc_data["nested"].should have_key("iv")
+
+      iv = @enc_data["nested"]["iv"]
+      encryptor = Chef::EncryptedDataBagItem::Encryptor.new(@plain_data["nested"], @secret, iv)
+
+      @enc_data["nested"]["encrypted_data"].should == encryptor.for_encrypted_item["encrypted_data"]
     end
+
   end
 
-  shared_examples_for "a decrypted data bag item" do
+  describe "decrypting" do
+    before(:each) do
+      @enc_data = Chef::EncryptedDataBagItem.encrypt_data_bag_item(@plain_data,
+                                                                   @secret)
+      @eh = Chef::EncryptedDataBagItem.new(@enc_data, @secret)
+    end
 
     it "doesn't try to decrypt 'id'" do
       @eh["id"].should == @plain_data["id"]
@@ -226,32 +197,6 @@ describe Chef::EncryptedDataBagItem do
     end
   end
 
-  describe "decrypting" do
-    before(:each) do
-      @enc_data = Chef::EncryptedDataBagItem.encrypt_data_bag_item(@plain_data,
-                                                                   @secret)
-      @eh = Chef::EncryptedDataBagItem.new(@enc_data, @secret)
-    end
-
-    it_behaves_like "a decrypted data bag item"
-  end
-
-  describe "when decrypting a version 1 (Chef 11.x) data bag item" do
-    before do
-      @enc_data = @plain_data.inject({}) do |encrypted, (key, value)|
-        if key == "id"
-          encrypted["id"] = value
-        else
-          encrypted[key] = Version1Encryptor.new(value, @secret).for_encrypted_item
-        end
-        encrypted
-      end
-      @eh = Chef::EncryptedDataBagItem.new(@enc_data, @secret)
-    end
-
-    it_behaves_like "a decrypted data bag item"
-  end
-
   describe "loading" do
     it "should defer to Chef::DataBagItem.load" do
       Chef::DataBagItem.stub(:load).with(:the_bag, "my_codes").and_return(@enc_data)