chef 10.28.2-x86-mingw32

data/spec/unit/checksum_spec.rb

@@ -0,0 +1,94 @@
+#
+# Author:: Daniel DeLeo (<dan@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/checksum'
+
+describe Chef::Checksum do
+
+  before do
+    Chef::Log.logger = Logger.new(StringIO.new)
+
+    @now = Time.now
+
+    Time.stub!(:now).and_return(@now)
+
+    @checksum_of_the_file = "3fafecfb15585ede6b840158cbc2f399"
+    @checksum = Chef::Checksum.new(@checksum_of_the_file)
+  end
+
+  it "has no original committed file location" do
+    @checksum.original_committed_file_location.should be_nil
+  end
+
+  it "has the MD5 checksum of the file it represents" do
+    @checksum.checksum.should == @checksum_of_the_file
+  end
+
+  it "stores the time it was created" do
+    @checksum.create_time.should == @now.iso8601
+  end
+
+  it "commits a sandbox file from a given location to the checksum repo location" do
+    @checksum.storage.should_receive(:commit).with("/tmp/arbitrary_file_location")
+    @checksum.should_receive(:cdb_save)
+    @checksum.commit_sandbox_file("/tmp/arbitrary_file_location")
+    @checksum.original_committed_file_location.should == "/tmp/arbitrary_file_location"
+  end
+
+  it "reverts committing a sandbox file" do
+    @checksum.storage.should_receive(:commit).with("/tmp/arbitrary_file_location")
+    @checksum.should_receive(:cdb_save)
+    @checksum.commit_sandbox_file("/tmp/arbitrary_file_location")
+    @checksum.original_committed_file_location.should == "/tmp/arbitrary_file_location"
+
+    @checksum.storage.should_receive(:revert).with("/tmp/arbitrary_file_location")
+    @checksum.should_receive(:cdb_destroy)
+    @checksum.revert_sandbox_file_commit
+  end
+
+  it "raises an error when trying to revert a checksum that was not previously committed" do
+    lambda {@checksum.revert_sandbox_file_commit}.should raise_error(Chef::Exceptions::IllegalChecksumRevert)
+  end
+
+  it "deletes the file and its document from couchdb" do
+    @checksum.should_receive(:cdb_destroy)
+    @checksum.storage.should_receive(:purge)
+    @checksum.purge
+  end
+
+  describe "when converted to json" do
+    before do
+      @checksum_as_json = @checksum.to_json
+      @checksum_as_hash_from_json = Chef::JSONCompat.from_json(@checksum_as_json, :create_additions => false)
+    end
+
+    it "contains the file's MD5 checksum" do
+      @checksum_as_hash_from_json["checksum"].should == @checksum_of_the_file
+    end
+
+    it "contains the creation time" do
+      @checksum_as_hash_from_json["create_time"].should == @now.iso8601
+    end
+
+    it "uses the file's MD5 checksum for its 'name' property" do
+      @checksum_as_hash_from_json["name"].should == @checksum_of_the_file
+    end
+  end
+
+end

data/spec/unit/chef_spec.rb

@@ -0,0 +1,25 @@
+#
+# 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 do
+  it "should have a version defined" do
+    Chef::VERSION.should match(/(\d+)\.(\d+)\.(\d+)/)
+  end
+end

data/spec/unit/client_spec.rb

@@ -0,0 +1,290 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright 2008-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/run_context'
+require 'chef/rest'
+require 'rbconfig'
+
+shared_examples_for Chef::Client do
+  before do
+    Chef::Log.logger = Logger.new(StringIO.new)
+
+    # Node/Ohai data
+    @hostname = "hostname"
+    @fqdn = "hostname.example.org"
+    Chef::Config[:node_name] = @fqdn
+    ohai_data = { :fqdn             => @fqdn,
+                  :hostname         => @hostname,
+                  :platform         => 'example-platform',
+                  :platform_version => 'example-platform',
+                  :data             => {} }
+    ohai_data.stub!(:all_plugins).and_return(true)
+    ohai_data.stub!(:data).and_return(ohai_data[:data])
+    Ohai::System.stub!(:new).and_return(ohai_data)
+
+    @node = Chef::Node.new(@hostname)
+    @node.name(@fqdn)
+    @node.chef_environment("_default")
+    @node[:platform] = "example-platform"
+    @node[:platform_version] = "example-platform-1.0"
+
+    @client = Chef::Client.new
+    @client.node = @node
+  end
+
+  describe "authentication protocol selection" do
+    after do
+      Chef::Config[:authentication_protocol_version] = "1.0"
+    end
+
+    context "when the node name is <= 90 bytes" do
+      it "does not force the authentication protocol to 1.1" do
+        Chef::Config[:node_name] = ("f" * 90)
+        # ugly that this happens as a side effect of a getter :(
+        @client.node_name
+        Chef::Config[:authentication_protocol_version].should == "1.0"
+      end
+    end
+
+    context "when the node name is > 90 bytes" do
+      it "sets the authentication protocol to version 1.1" do
+        Chef::Config[:node_name] = ("f" * 91)
+        # ugly that this happens as a side effect of a getter :(
+        @client.node_name
+        Chef::Config[:authentication_protocol_version].should == "1.1"
+      end
+    end
+  end
+
+  describe "run" do
+
+    it "should identify the node and run ohai, then register the client" do
+      mock_chef_rest_for_node = mock("Chef::REST (node)")
+      mock_chef_rest_for_client = mock("Chef::REST (client)")
+      mock_chef_rest_for_node_save = mock("Chef::REST (node save)")
+      mock_chef_runner = mock("Chef::Runner")
+
+      # --Client.register
+      #   Make sure Client#register thinks the client key doesn't
+      #   exist, so it tries to register and create one.
+      File.should_receive(:exists?).with(Chef::Config[:client_key]).exactly(1).times.and_return(false)
+
+      #   Client.register will register with the validation client name.
+      Chef::REST.should_receive(:new).with(Chef::Config[:client_url], Chef::Config[:validation_client_name], Chef::Config[:validation_key]).exactly(1).and_return(mock_chef_rest_for_client)
+      mock_chef_rest_for_client.should_receive(:register).with(@fqdn, Chef::Config[:client_key]).exactly(1).and_return(true)
+      #   Client.register will then turn around create another
+      
+      #   Chef::REST object, this time with the client key it got from the
+      #   previous step.
+      Chef::REST.should_receive(:new).with(Chef::Config[:chef_server_url], @fqdn, Chef::Config[:client_key]).exactly(1).and_return(mock_chef_rest_for_node)
+
+      # --Client#build_node
+      #   looks up the node, which we will return, then later saves it.
+      Chef::Node.should_receive(:find_or_create).with(@fqdn).and_return(@node)
+
+      # --ResourceReporter#node_load_completed
+      #   gets a run id from the server for storing resource history
+      #   (has its own tests, so stubbing it here.)
+      Chef::ResourceReporter.any_instance.should_receive(:node_load_completed)
+
+      # --ResourceReporter#run_completed
+      #   updates the server with the resource history
+      #   (has its own tests, so stubbing it here.)
+      Chef::ResourceReporter.any_instance.should_receive(:run_completed)
+      # --Client#setup_run_context
+      # ---Client#sync_cookbooks -- downloads the list of cookbooks to sync
+      #
+      Chef::CookbookSynchronizer.any_instance.should_receive(:sync_cookbooks)
+      mock_chef_rest_for_node.should_receive(:post_rest).with("environments/_default/cookbook_versions", {:run_list => []}).and_return({})
+
+      # --Client#converge
+      Chef::Runner.should_receive(:new).and_return(mock_chef_runner)
+      mock_chef_runner.should_receive(:converge).and_return(true)
+
+      # --Client#save_updated_node
+      Chef::REST.should_receive(:new).with(Chef::Config[:chef_server_url]).and_return(mock_chef_rest_for_node_save)
+      mock_chef_rest_for_node_save.should_receive(:put_rest).with("nodes/#{@fqdn}", @node).and_return(true)
+
+      # Post conditions: check that node has been filled in correctly
+      @client.should_receive(:run_started)
+      @client.should_receive(:run_completed_successfully)
+
+      if(Chef::Config[:client_fork])
+        require 'stringio'
+        if(Chef::Config[:pipe_node])
+          pipe_sim = StringIO.new
+          pipe_sim.should_receive(:close).exactly(4).and_return(nil)
+          res = ''
+          pipe_sim.should_receive(:puts) do |string|
+            res.replace(string)
+          end
+          pipe_sim.should_receive(:gets).and_return(res)
+          Chef::CouchDB.should_receive(:new).and_return(nil)
+          IO.should_receive(:pipe).and_return([pipe_sim, pipe_sim])
+          IO.should_receive(:select).and_return(true)
+        end
+        proc_ret = Class.new.new
+        proc_ret.should_receive(:success?).and_return(true)
+        Process.should_receive(:waitpid2).and_return([1, proc_ret])
+        @client.should_receive(:exit).and_return(nil)
+        @client.should_receive(:fork) do |&block|
+          block.call
+        end
+      end
+      
+      # This is what we're testing.
+      @client.run
+
+      if(!Chef::Config[:client_fork] || Chef::Config[:pipe_node])
+        @node.automatic_attrs[:platform].should == "example-platform"
+        @node.automatic_attrs[:platform_version].should == "example-platform-1.0"
+      end
+    end
+    
+    describe "when notifying other objects of the status of the chef run" do
+      before do
+        Chef::Client.clear_notifications
+        Chef::Node.stub!(:find_or_create).and_return(@node)
+        @node.stub!(:save)
+        @client.build_node
+      end
+
+      it "notifies observers that the run has started" do
+        notified = false
+        Chef::Client.when_run_starts do |run_status|
+          run_status.node.should == @node
+          notified = true
+        end
+
+        @client.run_started
+        notified.should be_true
+      end
+
+      it "notifies observers that the run has completed successfully" do
+        notified = false
+        Chef::Client.when_run_completes_successfully do |run_status|
+          run_status.node.should == @node
+          notified = true
+        end
+
+        @client.run_completed_successfully
+        notified.should be_true
+      end
+
+      it "notifies observers that the run failed" do
+        notified = false
+        Chef::Client.when_run_fails do |run_status|
+          run_status.node.should == @node
+          notified = true
+        end
+
+        @client.run_failed
+        notified.should be_true
+      end
+    end
+  end
+
+  describe "build_node" do
+    it "should expand the roles and recipes for the node" do
+      @node.run_list << "role[role_containing_cookbook1]"
+      role_containing_cookbook1 = Chef::Role.new
+      role_containing_cookbook1.name("role_containing_cookbook1")
+      role_containing_cookbook1.run_list << "cookbook1"
+
+      # build_node will call Node#expand! with server, which will
+      # eventually hit the server to expand the included role.
+      mock_chef_rest = mock("Chef::REST")
+      mock_chef_rest.should_receive(:get_rest).with("roles/role_containing_cookbook1").and_return(role_containing_cookbook1)
+      Chef::REST.should_receive(:new).and_return(mock_chef_rest)
+
+      # check pre-conditions.
+      @node[:roles].should be_nil
+      @node[:recipes].should be_nil
+
+      @client.build_node
+
+      # check post-conditions.
+      @node[:roles].should_not be_nil
+      @node[:roles].length.should == 1
+      @node[:roles].should include("role_containing_cookbook1")
+      @node[:recipes].should_not be_nil
+      @node[:recipes].length.should == 1
+      @node[:recipes].should include("cookbook1")
+    end
+  end
+
+  describe "when a run list override is provided" do
+    before do
+      @node = Chef::Node.new(@hostname)
+      @node.name(@fqdn)
+      @node.chef_environment("_default")
+      @node[:platform] = "example-platform"
+      @node[:platform_version] = "example-platform-1.0"
+    end
+
+    it "should permit spaces in overriding run list" do
+      @client = Chef::Client.new(nil, :override_runlist => 'role[a], role[b]')
+    end
+
+    it "should override the run list and save original runlist" do
+      @client = Chef::Client.new(nil, :override_runlist => 'role[test_role]')
+      @client.node = @node
+
+      @node.run_list << "role[role_containing_cookbook1]"
+
+      override_role = Chef::Role.new
+      override_role.name 'test_role'
+      override_role.run_list << 'cookbook1'
+
+      original_runlist = @node.run_list.dup
+
+      mock_chef_rest = mock("Chef::REST")
+      mock_chef_rest.should_receive(:get_rest).with("roles/test_role").and_return(override_role)
+      Chef::REST.should_receive(:new).and_return(mock_chef_rest)
+
+      @node.should_receive(:save).and_return(nil)
+
+      @client.build_node
+      
+      @node[:roles].should_not be_nil
+      @node[:roles].should eql(['test_role'])
+      @node[:recipes].should eql(['cookbook1'])
+
+      @client.save_updated_node
+
+      @node.run_list.should == original_runlist
+
+    end
+  end
+
+end
+
+describe Chef::Client do
+  it_behaves_like Chef::Client
+end
+
+describe "Chef::Client Forked" do
+  it_behaves_like Chef::Client
+  before do
+    Chef::Config[:client_fork] = true
+  end
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,223 @@
+#
+# 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::Config do
+  before(:all) do
+    @original_config = Chef::Config.hash_dup
+    @original_env = { 'HOME' => ENV['HOME'], 'SYSTEMDRIVE' => ENV['SYSTEMDRIVE'], 'HOMEPATH' => ENV['HOMEPATH'], 'USERPROFILE' => ENV['USERPROFILE'] }
+  end
+
+  shared_examples_for "server URL" do
+    it "should set the registration url" do
+      Chef::Config.registration_url.should == "https://junglist.gen.nz"
+    end
+
+    it "should set the template url" do
+      Chef::Config.template_url.should == "https://junglist.gen.nz"
+    end
+
+    it "should set the remotefile url" do
+      Chef::Config.remotefile_url.should == "https://junglist.gen.nz"
+    end
+
+    it "should set the search url" do
+      Chef::Config.search_url.should == "https://junglist.gen.nz"
+    end
+
+    it "should set the role url" do
+      Chef::Config.role_url.should == "https://junglist.gen.nz"
+    end
+  end
+
+  describe "config attribute writer: chef_server_url" do
+    before do
+      Chef::Config.chef_server_url = "https://junglist.gen.nz"
+    end
+    
+    it_behaves_like "server URL"
+  end
+
+  context "when the url has a leading space" do
+    before do
+      Chef::Config.chef_server_url = " https://junglist.gen.nz"
+    end
+    
+    it_behaves_like "server URL"
+  end
+
+  context "when the url is a frozen string" do
+    before do
+      Chef::Config.chef_server_url = " https://junglist.gen.nz".freeze
+    end
+
+    it_behaves_like "server URL"
+  end
+
+  describe "class method: manage_secret_key" do
+    before do
+      Chef::FileCache.stub!(:load).and_return(true)
+      Chef::FileCache.stub!(:has_key?).with("chef_server_cookie_id").and_return(false)
+    end
+
+    it "should generate and store a chef server cookie id" do
+      Chef::FileCache.should_receive(:store).with("chef_server_cookie_id", /\w{40}/).and_return(true)
+      Chef::Config.manage_secret_key
+    end
+
+    describe "when the filecache has a chef server cookie id key" do
+      before do
+        Chef::FileCache.stub!(:has_key?).with("chef_server_cookie_id").and_return(true)
+      end
+
+      it "should not generate and store a chef server cookie id" do
+        Chef::FileCache.should_not_receive(:store).with("chef_server_cookie_id", /\w{40}/).and_return(true)
+        Chef::Config.manage_secret_key
+      end
+    end
+
+  end
+
+  describe "config attribute writer: log_method=" do
+    describe "when given an object that responds to sync= e.g. IO" do
+      it "should configure itself to use the IO as log_location" do
+        Chef::Config.log_location = STDOUT
+        Chef::Config.log_location.should == STDOUT
+      end
+    end
+
+    describe "when given an object that is stringable (to_str)" do
+      before do
+        @mockfile = mock("File", :path => "/var/log/chef/client.log", :sync= => true)
+        File.should_receive(:new).
+          with("/var/log/chef/client.log", "a").
+          and_return(@mockfile)
+      end
+
+      after do
+        Chef::Config.log_location = STDOUT
+      end
+
+      it "should configure itself to use a File object based upon the String" do
+        Chef::Config.log_location = "/var/log/chef/client.log"
+        Chef::Config.log_location.path.should == "/var/log/chef/client.log"
+      end
+    end
+  end
+
+  describe "class method: openid_providers=" do
+    it "should not log an appropriate deprecation info message" do
+      Chef::Log.should_not_receive(:info).with("DEPRECATION: openid_providers will be removed, please use authorized_openid_providers").and_return(true)
+      Chef::Config.openid_providers = %w{opscode.com junglist.gen.nz}
+    end
+
+    it "should internally configure authorized_openid_providers with the value given" do
+      Chef::Config.should_receive(:configure).and_return(%w{opscode.com junglist.gen.nz})
+      Chef::Config.openid_providers = %w{opscode.com junglist.gen.nz}
+    end
+  end
+
+   describe "class method: plaform_specific_path" do
+    it "should return given path on non-windows systems" do
+      platform_mock :unix do
+        path = "/etc/chef/cookbooks"
+        Chef::Config.platform_specific_path(path).should == "/etc/chef/cookbooks"
+      end
+    end
+
+    it "should return a windows path on windows systems" do
+      platform_mock :windows do
+        path = "/etc/chef/cookbooks"
+        ENV.stub!(:[]).with('SYSTEMDRIVE').and_return('C:')
+        # match on a regex that looks for the base path with an optional
+        # system drive at the beginning (c:)
+        # system drive is not hardcoded b/c it can change and b/c it is not present on linux systems
+        Chef::Config.platform_specific_path(path).should == "C:\\chef\\cookbooks"
+      end
+    end
+  end
+
+  describe "default values" do
+    before(:each) do
+      # reload Chef::Config to ensure defaults are truely active
+      load File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib", "chef", "config.rb"))
+    end
+
+    after(:each) do
+      # reload spec helper to re-set any spec specific Chef::Config values
+      load File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper.rb"))
+    end
+
+    it "Chef::Config[:file_backup_path] defaults to /var/chef/backup" do
+      backup_path = if windows?
+        "#{ENV['SYSTEMDRIVE']}\\chef\\backup"
+      else
+        "/var/chef/backup"
+      end
+      Chef::Config[:file_backup_path].should == backup_path
+    end
+
+    it "Chef::Config[:ssl_verify_mode] defaults to :verify_none" do
+      Chef::Config[:ssl_verify_mode].should == :verify_none
+    end
+
+    it "Chef::Config[:ssl_ca_path] defaults to nil" do
+      Chef::Config[:ssl_ca_path].should be_nil
+    end
+
+    it "Chef::Config[:ssl_ca_file] defaults to nil" do
+      Chef::Config[:ssl_ca_file].should be_nil
+    end
+
+    it "Chef::Config[:data_bag_path] defaults to /var/chef/data_bags" do
+      data_bag_path = if windows?
+        "C:\\chef\\data_bags"
+      else
+        "/var/chef/data_bags"
+      end
+
+      Chef::Config[:data_bag_path].should == data_bag_path
+    end
+  end
+
+  describe "Chef::Config[:user_home]" do
+    it "should set when HOME is provided" do
+      ENV['HOME'] = "/home/kitten"
+      load File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib", "chef", "config.rb"))
+      Chef::Config[:user_home].should == "/home/kitten"
+    end
+
+    it "should be set when only USERPROFILE is provided" do
+      ENV['HOME'], ENV['SYSTEMDRIVE'],  ENV['HOMEPATH'] = nil, nil, nil
+      ENV['USERPROFILE'] = "/users/kitten"
+      load File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "lib", "chef", "config.rb"))
+      Chef::Config[:user_home].should == "/users/kitten"
+    end
+
+    after(:each) do
+      @original_env.each do |env_setting|
+        ENV[env_setting[0]] = env_setting[1]
+      end
+    end
+  end
+
+  after(:each) do
+    Chef::Config.configuration = @original_config
+  end
+end