chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/unit/environment_spec.rb

@@ -2,6 +2,7 @@
 # Author:: Stephen Delano (<stephen@ospcode.com>)
 # Author:: Seth Falcon (<seth@ospcode.com>)
 # Author:: John Keiser (<jkeiser@ospcode.com>)
+# Author:: Kyle Goodwin (<kgoodwin@primerevenue.com>)
 # Copyright:: Copyright 2010-2011 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -235,107 +236,6 @@ describe Chef::Environment do
     end
   end
 
-  describe "when listing the available cookbooks filtered by policy" do
-    before(:each) do
-      @environment.name "prod"
-      @environment.cookbook_versions({
-        "apt" => "= 1.0.0",
-        "apache2" => "= 2.0.0"
-      })
-      Chef::Environment.stub!(:cdb_load).and_return @environment
-
-      @all_cookbooks = []
-      @all_cookbooks << begin
-        cv = Chef::CookbookVersion.new("apt")
-        cv.version = "1.0.0"
-        cv.recipe_filenames = ["default.rb", "only-in-1-0.rb"]
-        cv
-      end
-      @all_cookbooks << begin
-        cv = Chef::CookbookVersion.new("apt")
-        cv.version = "1.1.0"
-        cv.recipe_filenames = ["default.rb", "only-in-1-1.rb"]
-        cv
-      end
-      @all_cookbooks << begin
-        cv = Chef::CookbookVersion.new("apache2")
-        cv.version = "2.0.0"
-        cv.recipe_filenames = ["default.rb", "mod_ssl.rb"]
-        cv
-      end
-      @all_cookbooks << begin
-        cv = Chef::CookbookVersion.new("god")
-        cv.version = "4.2.0"
-        cv.recipe_filenames = ["default.rb"]
-        cv
-      end
-      Chef::CookbookVersion.stub!(:cdb_list).and_return @all_cookbooks
-    end
-
-    it "should load the environment" do
-      Chef::Environment.should_receive(:cdb_load).with("prod", nil)
-      Chef::Environment.cdb_load_filtered_cookbook_versions("prod")
-    end
-
-    it "should handle cookbooks with no available version" do
-      @environment.cookbook_versions({
-                                       "apt" => "> 999.0.0",
-                                       "apache2" => "= 2.0.0"
-                                     })
-      Chef::Environment.should_receive(:cdb_load).with("prod", nil)
-      recipes = Chef::Environment.cdb_load_filtered_recipe_list("prod")
-      # order doesn't matter
-      recipes.should =~ ["god", "apache2", "apache2::mod_ssl"]
-    end
-
-    
-    it "should load all the cookbook versions" do
-      Chef::CookbookVersion.should_receive(:cdb_list)
-      Chef::Environment.cdb_load_filtered_cookbook_versions("prod")
-      recipes = Chef::Environment.cdb_load_filtered_recipe_list("prod")
-      recipes.should =~ ["apache2", "apache2::mod_ssl", "apt",
-                         "apt::only-in-1-0", "god"]
-    end
-
-    it "should load all the cookbook versions with no policy" do
-      @environment.cookbook_versions({})
-      Chef::CookbookVersion.should_receive(:cdb_list)
-      Chef::Environment.cdb_load_filtered_cookbook_versions("prod")
-      recipes = Chef::Environment.cdb_load_filtered_recipe_list("prod")
-      recipes.should =~ ["apache2", "apache2::mod_ssl", "apt",
-                         "apt::only-in-1-1", "god"]
-    end
-
-    it "should restrict the cookbook versions, as specified in the environment" do
-      res = Chef::Environment.cdb_load_filtered_cookbook_versions("prod")
-      res["apt"].detect {|cb| cb.version == "1.0.0"}.should_not == nil
-      res["apache2"].detect {|cb| cb.version == "2.0.0"}.should_not == nil
-      res["god"].detect {|cb| cb.version == "4.2.0"}.should_not == nil
-    end
-
-    it "should produce correct results, regardless of the cookbook order in couch" do
-      # a bug present before the environments feature defaulted to the last CookbookVersion
-      # object for a cookbook as returned from couchdb when fetching cookbooks for a node
-      # this is a regression test
-      @all_cookbooks << begin
-        cv = Chef::CookbookVersion.new("god")
-        cv.version = "0.0.1"
-        cv
-      end
-      res = Chef::Environment.cdb_load_filtered_cookbook_versions("prod")
-      res["apt"].detect {|cb| cb.version == "1.0.0"}.should_not == nil
-      res["apache2"].detect {|cb| cb.version == "2.0.0"}.should_not == nil
-      res["god"].detect {|cb| cb.version == "4.2.0"}.should_not == nil
-    end
-
-    it "should return all versions of a cookbook that meet the version requirement" do
-      @environment.cookbook "apt", ">= 1.0.0"
-      res = Chef::Environment.cdb_load_filtered_cookbook_versions("prod")
-      res["apt"].detect {|cb| cb.version == "1.0.0"}.should_not == nil
-      res["apt"].detect {|cb| cb.version == "1.1.0"}.should_not == nil
-    end
-  end
-
   describe "self.validate_cookbook_versions" do
     before(:each) do
       @cookbook_versions = {
@@ -372,37 +272,27 @@ describe Chef::Environment do
       Chef::Environment.validate_cookbook_version(Chef::CookbookVersion.new("meta")).should == false
       Chef::Environment.validate_cookbook_version("= 1.2.3a").should == false
       Chef::Environment.validate_cookbook_version("= 1").should == false
+      Chef::Environment.validate_cookbook_version("= a").should == false
       Chef::Environment.validate_cookbook_version("= 1.2.3.4").should == false
     end
-  end
 
-  describe "self.create_default_environment" do
-    it "should check if the '_default' environment exists" do
-      @couchdb = Chef::CouchDB.new
-      Chef::CouchDB.stub!(:new).and_return @couchdb
-      Chef::Environment.should_receive(:cdb_load).with('_default', Chef::CouchDB.new)
-      Chef::Environment.create_default_environment
-    end
-
-    it "should not re-create the environment if it exists" do
-      @couchdb = Chef::CouchDB.new
-      Chef::CouchDB.stub!(:new).and_return @couchdb
-      Chef::Environment.should_receive(:cdb_load).with('_default', Chef::CouchDB.new).and_return true
-      Chef::Environment.should_not_receive(:new)
-      Chef::Environment.create_default_environment
-    end
+    describe "in solo mode" do
+      before do
+        Chef::Config[:solo] = true
+      end
 
-    it "should create the environment if it doesn't exist" do
-      @env = Chef::Environment.new
-      @env.stub!(:cdb_save).and_return true
-      @couchdb = Chef::CouchDB.new
-      Chef::Environment.stub!(:new).and_return @env
-      Chef::CouchDB.stub!(:new).and_return @couchdb
+      after do
+        Chef::Config[:solo] = false
+      end
 
-      Chef::Environment.should_receive(:cdb_load).with('_default', Chef::CouchDB.new).and_raise(Chef::Exceptions::CouchDBNotFound)
-      Chef::Environment.should_receive(:new)
-      Chef::Environment.create_default_environment
+      it "should raise and exception" do
+        lambda {
+          Chef::Environment.validate_cookbook_version("= 1.2.3.4")
+        }.should raise_error Chef::Exceptions::IllegalVersionConstraint,
+                             "Environment cookbook version constraints not allowed in chef-solo"
+      end
     end
+
   end
 
   describe "when updating from a parameter hash" do
@@ -489,4 +379,82 @@ describe Chef::Environment do
     end
   end
 
+  describe "when loading" do
+    describe "in solo mode" do
+      before do
+        Chef::Config[:solo] = true
+        Chef::Config[:environment_path] = '/var/chef/environments'
+      end
+
+      after do
+        Chef::Config[:solo] = false
+      end
+
+      it "should get the environment from the environment_path" do
+        File.should_receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
+        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(false)
+        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).exactly(2).times.and_return(true)
+        File.should_receive(:readable?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(true)
+        role_dsl="name \"foo\"\ndescription \"desc\"\n"
+        IO.should_receive(:read).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(role_dsl)
+        Chef::Environment.load('foo')
+      end
+
+      it "should return a Chef::Environment object from JSON" do
+        File.should_receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
+        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(true)
+        environment_hash = {
+          "name" => "foo",
+          "default_attributes" => {
+            "foo" => {
+              "bar" => 1
+            }
+          },
+          "json_class" => "Chef::Environment",
+          "description" => "desc",
+          "chef_type" => "environment"
+        }
+        IO.should_receive(:read).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(JSON.dump(environment_hash))
+        environment = Chef::Environment.load('foo')
+
+        environment.should be_a_kind_of(Chef::Environment)
+        environment.name.should == environment_hash['name']
+        environment.description.should == environment_hash['description']
+        environment.default_attributes.should == environment_hash['default_attributes']
+      end
+
+      it "should return a Chef::Environment object from Ruby DSL" do
+        File.should_receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
+        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(false)
+        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).exactly(2).times.and_return(true)
+        File.should_receive(:readable?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(true)
+        role_dsl="name \"foo\"\ndescription \"desc\"\n"
+        IO.should_receive(:read).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(role_dsl)
+        environment = Chef::Environment.load('foo')
+
+        environment.should be_a_kind_of(Chef::Environment)
+        environment.name.should == 'foo'
+        environment.description.should == 'desc'
+      end
+
+      it 'should raise an error if the configured environment_path is invalid' do
+        File.should_receive(:directory?).with(Chef::Config[:environment_path]).and_return(false)
+
+        lambda {
+          Chef::Environment.load('foo')
+        }.should raise_error Chef::Exceptions::InvalidEnvironmentPath, "Environment path '/var/chef/environments' is invalid"
+      end
+
+      it 'should raise an error if the file does not exist' do
+        File.should_receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
+        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(false)
+        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(false)
+
+        lambda {
+          Chef::Environment.load('foo')
+        }.should raise_error Chef::Exceptions::EnvironmentNotFound, "Environment 'foo' could not be loaded from disk"
+      end
+    end
+  end
+
 end

data/spec/unit/exceptions_spec.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
 # Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Kyle Goodwin (<kgoodwin@primerevenue.com>)
 # Copyright:: Copyright (c) 2010 Thomas Bishop
 # Copyright:: Copyright (c) 2010 Opscode, Inc.
 # License:: Apache License, Version 2.0
@@ -8,9 +9,9 @@
 # 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.
@@ -40,7 +41,6 @@ describe Chef::Exceptions do
     Chef::Exceptions::Group => RuntimeError,
     Chef::Exceptions::Link => RuntimeError,
     Chef::Exceptions::Mount => RuntimeError,
-    Chef::Exceptions::CouchDBNotFound => RuntimeError,
     Chef::Exceptions::PrivateKeyMissing => RuntimeError,
     Chef::Exceptions::CannotWritePrivateKey => RuntimeError,
     Chef::Exceptions::RoleNotFound => RuntimeError,
@@ -63,7 +63,11 @@ describe Chef::Exceptions do
     Chef::Exceptions::ResourceNotFound => RuntimeError,
     Chef::Exceptions::InvalidResourceSpecification => ArgumentError,
     Chef::Exceptions::SolrConnectionError => RuntimeError,
-    Chef::Exceptions::InvalidDataBagPath => ArgumentError
+    Chef::Exceptions::InvalidDataBagPath => ArgumentError,
+    Chef::Exceptions::InvalidEnvironmentPath => ArgumentError,
+    Chef::Exceptions::EnvironmentNotFound => RuntimeError,
+    Chef::Exceptions::InvalidVersionConstraint => ArgumentError,
+    Chef::Exceptions::IllegalVersionConstraint => NotImplementedError
   }
 
   exception_to_super_class.each do |exception, expected_super_class|

data/spec/unit/file_access_control_spec.rb

@@ -36,7 +36,7 @@ describe Chef::FileAccessControl do
         @run_context = Chef::RunContext.new(@node, {}, @events)
         @current_resource = Chef::Resource::File.new('/tmp/different_file.txt')
         @provider_requirements = Chef::Provider::ResourceRequirements.new(@resource, @run_context)
-        @provider = mock("File provider", :requirements => @provider_requirements)
+        @provider = mock("File provider", :requirements => @provider_requirements, :manage_symlink_access? => false)
 
         @fac = Chef::FileAccessControl.new(@current_resource, @resource, @provider)
       end
@@ -105,7 +105,14 @@ describe Chef::FileAccessControl do
       @fac.target_uid.should == 4294967286
     end
 
+    it "wants to update the owner when the current owner is nil (creating a file)" do
+      @current_resource.owner(nil)
+      @resource.owner(2342)
+      @fac.should_update_owner?.should be_true
+    end
+
     it "wants to update the owner when the current owner doesn't match desired" do
+      @current_resource.owner(3224)
       @resource.owner(2342)
       @fac.should_update_owner?.should be_true
     end
@@ -171,6 +178,12 @@ describe Chef::FileAccessControl do
       lambda { @fac.target_gid; @provider_requirements.run(:create) }.should raise_error(ArgumentError)
     end
 
+    it "wants to update the group when the current group is nil (creating a file)" do
+      @resource.group(2342)
+      @current_resource.group(nil)
+      @fac.should_update_group?.should be_true
+    end
+
     it "wants to update the group when the current group doesn't match the target group" do
       @resource.group(2342)
       @current_resource.group(815)
@@ -232,7 +245,14 @@ describe Chef::FileAccessControl do
       fac.should_update_mode?.should be_false
     end
 
+    it "wants to update the mode when the current mode is nil (creating a file)" do
+      @resource.mode("0400")
+      @current_resource.mode(nil)
+      @fac.should_update_mode?.should be_true
+    end
+
     it "wants to update the mode when the desired mode does not match the current mode" do
+      @resource.mode("0400")
       @current_resource.mode("0644")
       @fac.should_update_mode?.should be_true
     end

data/spec/unit/file_content_management/deploy/cp_spec.rb

@@ -0,0 +1,46 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2013 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::FileContentManagement::Deploy::Cp do
+
+  let(:content_deployer) { described_class.new }
+  let(:target_file_path) { "/etc/my_app.conf" }
+
+  describe "creating the file" do
+
+    it "touches the file to create it" do
+      FileUtils.should_receive(:touch).with(target_file_path)
+      content_deployer.create(target_file_path)
+    end
+  end
+
+  describe "updating the file" do
+
+    let(:staging_file_path) { "/tmp/random-dir/staging-file.tmp" }
+
+    it "copies the staging file's content" do
+      FileUtils.should_receive(:cp).with(staging_file_path, target_file_path)
+      content_deployer.deploy(staging_file_path, target_file_path)
+    end
+
+  end
+end
+
+

data/spec/unit/file_content_management/deploy/mv_unix_spec.rb

@@ -0,0 +1,103 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2013 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::FileContentManagement::Deploy::MvUnix do
+
+  let(:content_deployer) { described_class.new }
+  let(:target_file_path) { "/etc/my_app.conf" }
+
+  describe "creating the file" do
+
+    it "touches the file to create it" do
+      FileUtils.should_receive(:touch).with(target_file_path)
+      content_deployer.create(target_file_path)
+    end
+  end
+
+  describe "updating the file" do
+
+    let(:staging_file_path) { "/tmp/random-dir/staging-file.tmp" }
+
+    let(:target_file_mode) { 0644 }
+    let(:target_file_stat) do
+      mock "File::Stat struct for target file",
+           :mode => target_file_mode,
+           :uid => target_file_uid,
+           :gid => target_file_gid
+    end
+
+    before do
+      File.should_receive(:stat).with(target_file_path).and_return(target_file_stat)
+      File.should_receive(:chmod).with(target_file_mode, staging_file_path).and_return(1)
+      FileUtils.should_receive(:mv).with(staging_file_path, target_file_path)
+    end
+
+    # This context represents the case where:
+    # * Chef runs as root
+    # * The owner and group of the target file match the owner and group of the
+    #   staging file.
+    context "when the user has permissions to set file ownership" do
+
+      # For the purposes of this test, the uid/gid can be anything. These
+      # values are just chosen because (assuming chef-client's euid == 1001 and
+      # egid == 1001), the `chown` call is allowed by the OS. See the
+      # description of `EPERM` in `man 2 chown` for reference.
+      let(:target_file_uid) { 1001 }
+      let(:target_file_gid) { 1001 }
+
+      before do
+        File.should_receive(:chown).with(target_file_uid, nil, staging_file_path).and_return(1)
+        File.should_receive(:chown).with(nil, target_file_gid, staging_file_path).and_return(1)
+      end
+
+      it "fixes up permissions and moves the file into place" do
+        content_deployer.deploy(staging_file_path, target_file_path)
+      end
+
+    end
+
+    context "when the user does not have permissions to set file ownership" do
+
+      # The test code does not care what these values are. These values are
+      # chosen because they're representitive of the case that chef-client is
+      # running as non-root and is managing a file that got ownership set to
+      # root somehow. In this example, gid==20 is something like "staff" which
+      # the user running chef-client is a member of (but it's not that user's
+      # primary group).
+      let(:target_file_uid) { 0 }
+      let(:target_file_gid) { 20 }
+
+      before do
+        File.should_receive(:chown).with(target_file_uid, nil, staging_file_path).and_raise(Errno::EPERM)
+        File.should_receive(:chown).with(nil, target_file_gid, staging_file_path).and_raise(Errno::EPERM)
+
+        Chef::Log.should_receive(:warn).with(/^Could not set uid/)
+        Chef::Log.should_receive(:warn).with(/^Could not set gid/)
+      end
+
+      it "fixes up permissions and moves the file into place" do
+        content_deployer.deploy(staging_file_path, target_file_path)
+      end
+    end
+
+  end
+end
+
+