chef 11.8.4.ohai7.0-x86-mingw32 → 11.10.0.alpha.1-x86-mingw32

data/lib/chef/resource/whyrun_safe_ruby_block.rb

@@ -0,0 +1,31 @@
+#
+# Author:: Phil Dibowitz (<phild@fb.com>)
+# Copyright:: Copyright (c) 2013 Facebook
+# 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.
+#
+
+class Chef
+  class Resource
+    class WhyrunSafeRubyBlock < Chef::Resource::RubyBlock
+
+      def initialize(name, run_context=nil)
+        super
+        @resource_name = :whyrun_safe_ruby_block
+        @provider = Chef::Provider::WhyrunSafeRubyBlock
+      end
+
+    end
+  end
+end

data/lib/chef/resources.rb

@@ -68,6 +68,7 @@ require 'chef/resource/smartos_package'
 require 'chef/resource/template'
 require 'chef/resource/timestamped_deploy'
 require 'chef/resource/user'
+require 'chef/resource/whyrun_safe_ruby_block'
 require 'chef/resource/yum_package'
 require 'chef/resource/lwrp_base'
 require 'chef/resource/bff_package'

data/lib/chef/run_context.rb

@@ -152,6 +152,17 @@ class Chef
       end
     end
 
+    def load_recipe_file(recipe_file)
+      if !File.exist?(recipe_file)
+        raise Chef::Exceptions::RecipeNotFound, "could not find recipe file #{recipe_file}"
+      end
+
+      Chef::Log.debug("Loading Recipe File #{recipe_file}")
+      recipe = Chef::Recipe.new('@recipe_files', recipe_file, self)
+      recipe.from_file(recipe_file)
+      recipe
+    end
+
     # Looks up an attribute file given the +cookbook_name+ and
     # +attr_file_name+. Used by DSL::IncludeAttribute
     def resolve_attribute(cookbook_name, attr_file_name)

data/lib/chef/shell/ext.rb

@@ -212,7 +212,7 @@ E
         puts  "This is the chef-shell.\n" +
               " Chef Version: #{::Chef::VERSION}\n" +
               " http://www.opscode.com/chef\n" +
-              " http://wiki.opscode.com/display/chef/Home"
+              " http://docs.opscode.com/"
         :ucanhaz_automation
       end
       alias :shell :version

data/lib/chef/util/windows/net_group.rb

@@ -63,7 +63,7 @@ class Chef::Util::Windows::NetGroup < Chef::Util::Windows
         members = 0.chr * (nread * (PTR_SIZE * 3)) #nread * sizeof(LOCALGROUP_MEMBERS_INFO_1)
         memcpy(members, ptr, members.size)
 
-        #3 pointer fields in LOCALGROUP_MEMBERS_INFO_1, offset 2*PTR_SIZE is lgrmi1_name
+        # 3 pointer fields in LOCALGROUP_MEMBERS_INFO_1, offset 2*PTR_SIZE is lgrmi1_name
         nread.times do |i|
           offset = (i * 3) + 2
           member = lpwstr_to_s(members, offset)
@@ -92,6 +92,10 @@ class Chef::Util::Windows::NetGroup < Chef::Util::Windows
     modify_members(members, NetLocalGroupAddMembers)
   end
 
+  def local_delete_members(members)
+    modify_members(members, NetLocalGroupDelMembers)
+  end
+
   def local_delete
     rc = NetLocalGroupDel.call(nil, @name)
     if rc != NERR_Success

data/lib/chef/version.rb

@@ -17,7 +17,7 @@
 
 class Chef
   CHEF_ROOT = File.dirname(File.expand_path(File.dirname(__FILE__)))
-  VERSION = '11.8.4.ohai7.0'
+  VERSION = '11.10.0.alpha.1'
 end
 
 # NOTE: the Chef::Version class is defined in version_class.rb

data/spec/functional/resource/base.rb

@@ -22,7 +22,9 @@ def ohai
   # provider is platform-dependent, we need platform ohai data:
   @OHAI_SYSTEM ||= begin
     ohai = Ohai::System.new
-    ohai.all_plugins("platform")
+    ohai.require_plugin("os")
+    ohai.require_plugin("platform")
+    ohai.require_plugin("passwd")
     ohai
   end
 end

data/spec/functional/resource/deploy_revision_spec.rb

@@ -45,7 +45,7 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
 
   before(:all) do
     @ohai = Ohai::System.new
-    @ohai.all_plugins("os")
+    @ohai.require_plugin("os")
   end
 
   let(:node) do

data/spec/functional/resource/git_spec.rb

@@ -92,7 +92,7 @@ E
 
   before(:all) do
     @ohai = Ohai::System.new
-    @ohai.all_plugins("os")
+    @ohai.require_plugin("os")
   end
 
   context "working with pathes with special characters" do

data/spec/functional/resource/group_spec.rb

@@ -20,33 +20,36 @@
 require 'spec_helper'
 require 'functional/resource/base'
 
-describe Chef::Resource::Group, :requires_root_or_running_windows do
-
-  def group_should_exist(resource)
+# Chef::Resource::Group are turned off on Mac OS X 10.6 due to caching
+# issues around Etc.getgrnam() not picking up the group membership
+# changes that are done on the system. Etc.endgrent is not functioning
+# correctly on certain 10.6 boxes.
+describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supported_on_mac_osx_106 do
+  def group_should_exist(group)
     case ohai[:platform_family]
     when "debian", "fedora", "rhel", "suse", "gentoo", "slackware", "arch"
-      expect { Etc::getgrnam(resource.name) }.to_not raise_error(ArgumentError, "can't find group for #{resource.name}")
-      expect(resource.name).to eq(Etc::getgrnam(resource.name).name)
+      expect { Etc::getgrnam(group) }.to_not raise_error(ArgumentError, "can't find group for #{group}")
+      expect(group).to eq(Etc::getgrnam(group).name)
     when "windows"
-      expect { Chef::Util::Windows::NetGroup.new(resource.group_name).local_get_members }.to_not raise_error(ArgumentError, "The group name could not be found.")
+      expect { Chef::Util::Windows::NetGroup.new(group).local_get_members }.to_not raise_error(ArgumentError, "The group name could not be found.")
     end
   end
 
-  def user_exist_in_group?(resource, user)
+  def user_exist_in_group?(user)
     case ohai[:platform_family]
-    when "debian", "fedora", "rhel", "suse", "gentoo", "slackware", "arch"
-      Etc::getgrnam(resource.name).mem.include?(user)
     when "windows"
-      Chef::Util::Windows::NetGroup.new(resource.group_name).local_get_members.include?(user)
+      Chef::Util::Windows::NetGroup.new(group_name).local_get_members.include?(user)
+    else
+      Etc::getgrnam(group_name).mem.include?(user)
     end
   end
 
-  def group_should_not_exist(resource)
+  def group_should_not_exist(group)
     case ohai[:platform_family]
     when "debian", "fedora", "rhel", "suse", "gentoo", "slackware", "arch"
-      expect { Etc::getgrnam(resource.name) }.to raise_error(ArgumentError, "can't find group for #{resource.name}")
+      expect { Etc::getgrnam(group) }.to raise_error(ArgumentError, "can't find group for #{group}")
     when "windows"
-      expect { Chef::Util::Windows::NetGroup.new(resource.group_name).local_get_members }.to raise_error(ArgumentError, "The group name could not be found.")
+      expect { Chef::Util::Windows::NetGroup.new(group).local_get_members }.to raise_error(ArgumentError, "The group name could not be found.")
     end
   end
 
@@ -54,151 +57,287 @@ describe Chef::Resource::Group, :requires_root_or_running_windows do
     return resource.gid == Etc::getgrnam(resource.name).gid if unix?
   end
 
-  def get_user_resource(username)
+  def user(username)
     usr = Chef::Resource::User.new("#{username}", run_context)
-    usr.password("Jetsream123!")
+    if ohai[:platform_family] == "windows"
+      usr.password("ComplexPass11!")
+    end
     usr
   end
 
   def create_user(username)
-    get_user_resource(username).run_action(:create)
+    user(username).run_action(:create)
+    # TODO: User shouldn't exist
   end
 
   def remove_user(username)
-    get_user_resource(username).run_action(:remove)
+    user(username).run_action(:remove)
+    # TODO: User shouldn't exist
   end
 
-  before do
-    @grp_resource = Chef::Resource::Group.new("test-group-#{SecureRandom.random_number(9999)}", run_context)
-  end
+  shared_examples_for "correct group management" do
+    def add_members_to_group(members)
+      temp_resource = group_resource.dup
+      temp_resource.members(members)
+      temp_resource.excluded_members([ ])
+      temp_resource.append(true)
+      temp_resource.run_action(:modify)
+      members.each do |member|
+        user_exist_in_group?(member).should == true
+      end
+    end
 
-  context "group create action" do
-    after(:each) do
-      @grp_resource.run_action(:remove)
+    def create_group
+      temp_resource = group_resource.dup
+      temp_resource.members([ ])
+      temp_resource.excluded_members([ ])
+      temp_resource.run_action(:create)
+      group_should_exist(group_name)
+      included_members.each do |member|
+        user_exist_in_group?(member).should == false
+      end
     end
 
-    it "create a group" do
-      @grp_resource.run_action(:create)
-      group_should_exist(@grp_resource)
+    before(:each) do
+      create_group
     end
 
-    context "group name with 256 characters", :windows_only do
-      before(:each) do
-        grp_name = "theoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestree"
-        @new_grp = Chef::Resource::Group.new(grp_name, run_context)
+    after(:each) do
+      group_resource.run_action(:remove)
+      group_should_not_exist(group_name)
+    end
+
+    describe "when append is not set" do
+      let(:included_members) { ["spec-Eric"] }
+
+      before do
+        create_user("spec-Eric")
+        create_user("spec-Gordon")
+        add_members_to_group(["spec-Gordon"])
       end
+
       after do
-        @new_grp.run_action(:remove)
+        remove_user("spec-Eric")
+        remove_user("spec-Gordon")
       end
-      it " create a group" do
-        @new_grp.run_action(:create)
-        group_should_exist(@new_grp)
+
+      it "should remove the existing users and add the new users to the group" do
+        group_resource.run_action(tested_action)
+
+        user_exist_in_group?("spec-Eric").should == true
+        user_exist_in_group?("spec-Gordon").should == false
       end
     end
-    context "group name with more than 256 characters", :windows_only do
+
+    describe "when append is set" do
       before(:each) do
-        grp_name = "theoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreeQQQQQQQQQQQQQQQQQ"
-        @new_grp = Chef::Resource::Group.new(grp_name, run_context)
+        group_resource.append(true)
       end
-      it " not create a group" do
-        expect { @new_grp.run_action(:create) }.to raise_error
-        group_should_not_exist(@new_grp)
+
+      describe "when the users exist" do
+        before do
+          (included_members + excluded_members).each do |member|
+            create_user(member)
+          end
+        end
+
+        after do
+          (included_members + excluded_members).each do |member|
+            remove_user(member)
+          end
+        end
+
+        it "should add included members to the group" do
+          group_resource.run_action(tested_action)
+
+          included_members.each do |member|
+            user_exist_in_group?(member).should == true
+          end
+          excluded_members.each do |member|
+            user_exist_in_group?(member).should == false
+          end
+        end
+
+        describe "when group contains some users" do
+          before(:each) do
+            add_members_to_group([ "spec-Gordon", "spec-Anthony" ])
+          end
+
+          it "should add the included users and remove excluded users" do
+            group_resource.run_action(tested_action)
+
+            included_members.each do |member|
+              user_exist_in_group?(member).should == true
+            end
+            excluded_members.each do |member|
+              user_exist_in_group?(member).should == false
+            end
+          end
+        end
+      end
+
+      describe "when the users doesn't exist" do
+        describe "when append is not set" do
+          it "should raise an error" do
+            lambda { @grp_resource.run_action(tested_action) }.should raise_error
+          end
+        end
+
+        describe "when append is set" do
+          it "should raise an error" do
+            lambda { @grp_resource.run_action(tested_action) }.should raise_error
+          end
+        end
       end
     end
   end
 
-  context "group remove action" do
-    before(:each) do
-      @grp_resource.run_action(:create)
+  let(:group_name) { "cheftest-#{SecureRandom.random_number(9999)}" }
+  let(:included_members) { nil }
+  let(:excluded_members) { nil }
+  let(:group_resource) {
+    group = Chef::Resource::Group.new(group_name, run_context)
+    group.members(included_members)
+    group.excluded_members(excluded_members)
+    group
+  }
+
+  it "append should be false by default" do
+    group_resource.append.should == false
+  end
+
+  describe "group create action" do
+    after(:each) do
+      group_resource.run_action(:remove)
+      group_should_not_exist(group_name)
+    end
+
+    it "should create a group" do
+      group_resource.run_action(:create)
+      group_should_exist(group_name)
+    end
+
+    describe "when group name is length 256", :windows_only do
+      let!(:group_name) { "theoldmanwalkingdownthestreetalwayshadagood\
+smileonhisfacetheoldmanwalkingdownthestreetalwayshadagoodsmileonhisface\
+theoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalking\
+downthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestree" }
+
+      it "should create a group" do
+        group_resource.run_action(:create)
+        group_should_exist(group_name)
+      end
     end
 
-    it "remove a group" do
-      @grp_resource.run_action(:remove)
-      group_should_not_exist(@grp_resource)
+    describe "when group name length is more than 256", :windows_only do
+      let!(:group_name) { "theoldmanwalkingdownthestreetalwayshadagood\
+smileonhisfacetheoldmanwalkingdownthestreetalwayshadagoodsmileonhisface\
+theoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalking\
+downthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreeQQQQQQ" }
+
+      it "should not create a group" do
+        lambda { group_resource.run_action(:create) }.should raise_error
+        group_should_not_exist(group_name)
+      end
+    end
+
+    # not_supported_on_solaris because of the use of excluded_members
+    describe "should raise an error when same member is included in the members and excluded_members", :not_supported_on_solaris do
+      it "should raise an error" do
+        invalid_resource = group_resource.dup
+        invalid_resource.members(["Jack"])
+        invalid_resource.excluded_members(["Jack"])
+        lambda { invalid_resource.run_action(:create)}.should raise_error(Chef::Exceptions::ConflictingMembersInGroup)
+      end
     end
   end
 
-  context "group modify action", :unsupported_group_provider_platform do
-    before(:each) do
-      @grp_resource.run_action(:create)
+  describe "group remove action" do
+    describe "when there is a group" do
+      before do
+        group_resource.run_action(:create)
+        group_should_exist(group_name)
+      end
+
+      it "should remove a group" do
+        group_resource.run_action(:remove)
+        group_should_not_exist(group_name)
+      end
     end
 
-    after(:each) do
-      @grp_resource.run_action(:remove)
-    end
-
-    it "add user to group" do
-      user1 = "user1-#{SecureRandom.random_number(9999)}"
-      user2 = "user2-#{SecureRandom.random_number(9999)}"
-
-      create_user(user1)
-      @grp_resource.members(user1)
-      expect(user_exist_in_group?(@grp_resource, user1)).to be_false
-      @grp_resource.run_action(:modify)
-      group_should_exist(@grp_resource)
-      expect(user_exist_in_group?(@grp_resource, user1)).to be_true
-
-      create_user(user2)
-      expect(user_exist_in_group?(@grp_resource, user2)).to be_false
-      @grp_resource.members(user2)
-      @grp_resource.run_action(:modify)
-      group_should_exist(@grp_resource)
-
-      #default append is false, so modify action remove old member user1 from group and add new member user2
-      expect(user_exist_in_group?(@grp_resource, user1)).to be_false
-      expect(user_exist_in_group?(@grp_resource, user2)).to be_true
-      remove_user(user1)
-      remove_user(user2)
-    end
-
-
-    it "append user to a group" do
-      user1 = "user1-#{SecureRandom.random_number(9999)}"
-      user2 = "user2-#{SecureRandom.random_number(9999)}"
-      create_user(user1)
-      @grp_resource.members(user1)
-      expect(user_exist_in_group?(@grp_resource, user1)).to be_false
-      #default append attribute is false
-      @grp_resource.run_action(:modify)
-      group_should_exist(@grp_resource)
-      expect(user_exist_in_group?(@grp_resource, user1)).to be_true
-      #set append attribute to true
-      @grp_resource.append(true)
-      create_user(user2)
-      expect(user_exist_in_group?(@grp_resource, user2)).to be_false
-      @grp_resource.members(user2)
-      @grp_resource.run_action(:modify)
-      group_should_exist(@grp_resource)
-      expect(user_exist_in_group?(@grp_resource, user1)).to be_true
-      expect(user_exist_in_group?(@grp_resource, user2)).to be_true
-      remove_user(user1)
-      remove_user(user2)
-    end
-
-    it "raise error on add non-existent user to group" do
-      user1 = "user1-#{SecureRandom.random_number(9999)}"
-      @grp_resource.members(user1)
-      @grp_resource.append(true)
-      expect(user_exist_in_group?(@grp_resource, user1)).to be_false
-      expect { @grp_resource.run_action(:modify) }.to raise_error
+    describe "when there is no group" do
+      it "should be no-op" do
+        group_resource.run_action(:remove)
+        group_should_not_exist(group_name)
+      end
     end
   end
 
-  context "group manage action", :unix_only, :unsupported_group_provider_platform do
-    before(:each) do
-      @grp_resource.run_action(:create)
+  describe "group modify action", :not_supported_on_solaris do
+    let(:included_members) { ["spec-Gordon", "spec-Eric"] }
+    let(:excluded_members) { ["spec-Anthony"] }
+    let(:tested_action) { :modify }
+
+    describe "when there is no group" do
+      it "should raise an error" do
+        lambda { group_resource.run_action(:modify) }.should raise_error
+      end
     end
 
-    after(:each) do
-      @grp_resource.run_action(:remove)
+    describe "when there is a group" do
+      it_behaves_like "correct group management"
+    end
+  end
+
+  describe "group manage action", :not_supported_on_solaris do
+    let(:included_members) { ["spec-Gordon", "spec-Eric"] }
+    let(:excluded_members) { ["spec-Anthony"] }
+    let(:tested_action) { :manage }
+
+    describe "when there is no group" do
+      it "should raise an error" do
+        lambda { group_resource.run_action(:manage) }.should_not raise_error
+        group_should_not_exist(group_name)
+      end
     end
 
-    it "change gid of the group" do
-      grp_id = 1234567890
-      @grp_resource.gid(grp_id)
-      @grp_resource.run_action(:manage)
-      group_should_exist(@grp_resource)
-      expect(compare_gid(@grp_resource, grp_id)).to be_true
+    describe "when there is a group" do
+      it_behaves_like "correct group management"
+    end
+  end
+
+  describe "group resource with Usermod provider", :solaris_only do
+    describe "when excluded_members is set" do
+      let(:excluded_members) { ["spec-Anthony"] }
+
+      it ":manage should raise an error" do
+        lambda {group_resource.run_action(:manage) }.should raise_error
+      end
+
+      it ":modify should raise an error" do
+        lambda {group_resource.run_action(:modify) }.should raise_error
+      end
+
+      it ":create should raise an error" do
+        lambda {group_resource.run_action(:create) }.should raise_error
+      end
+    end
+
+    describe "when append is not set" do
+      let(:included_members) { ["spec-Gordon", "spec-Eric"] }
+
+      before(:each) do
+        group_resource.append(false)
+      end
+
+      it ":manage should raise an error" do
+        lambda {group_resource.run_action(:manage) }.should raise_error
+      end
+
+      it ":modify should raise an error" do
+        lambda {group_resource.run_action(:modify) }.should raise_error
+      end
     end
   end
 end
+