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

data/spec/data/mac_users/10.9.shadow.xml

@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-        <key>SALTED-SHA512-PBKDF2</key>
-        <dict>
-                <key>entropy</key>
-                <data>
-                EmAakNsXy/i6SAjmOC+w07nYpsGhkEd79oCrIa+2BlRnE25VzCCKb3QVbj2v
-                IPsTNp70t7r6BH2ANZ+0akikrczVSOuzOFGwk0fMqENBp/k6JxRzQ/ifuEP7
-                RsABfSZK+kl2uqz5QbkVvR7ByiTDCz51ngJAPgL1n+f/WTinY2w=
-                </data>
-                <key>iterations</key>
-                <integer>34482</integer>
-                <key>salt</key>
-                <data>
-                7pVL5HL9xg3fiUhHgUM5k2JfAGr27IEMCPSafkE5RqE=
-                </data>
-        </dict>
-</dict>
-</plist>

data/spec/functional/resource/base.rb

@@ -1,40 +0,0 @@
-#
-# Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.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'
-
-def ohai
-  # provider is platform-dependent, we need platform ohai data:
-  @OHAI_SYSTEM ||= begin
-    ohai = Ohai::System.new
-    ohai.require_plugin("os")
-    ohai.require_plugin("platform")
-    ohai.require_plugin("passwd")
-    ohai
-  end
-end
-
-def run_context
-  @run_context ||= begin
-    node = Chef::Node.new
-    node.default[:platform] = ohai[:platform]
-    node.default[:platform_version] = ohai[:platform_version]
-    events = Chef::EventDispatch::Dispatcher.new
-    Chef::RunContext.new(node, {}, events)
-  end
-end

data/spec/functional/resource/group_spec.rb

@@ -1,343 +0,0 @@
-#
-# Author:: Chirag Jog (<chirag@clogeny.com>)
-# Author:: Siddheshwar More (<siddheshwar.more@clogeny.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'
-require 'functional/resource/base'
-
-# 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(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(group).local_get_members }.to_not raise_error(ArgumentError, "The group name could not be found.")
-    end
-  end
-
-  def user_exist_in_group?(user)
-    case ohai[:platform_family]
-    when "windows"
-      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(group)
-    case ohai[:platform_family]
-    when "debian", "fedora", "rhel", "suse", "gentoo", "slackware", "arch"
-      expect { Etc::getgrnam(group) }.to raise_error(ArgumentError, "can't find group for #{group}")
-    when "windows"
-      expect { Chef::Util::Windows::NetGroup.new(group).local_get_members }.to raise_error(ArgumentError, "The group name could not be found.")
-    end
-  end
-
-  def compare_gid(resource, gid)
-    return resource.gid == Etc::getgrnam(resource.name).gid if unix?
-  end
-
-  def user(username)
-    usr = Chef::Resource::User.new("#{username}", run_context)
-    if ohai[:platform_family] == "windows"
-      usr.password("ComplexPass11!")
-    end
-    usr
-  end
-
-  def create_user(username)
-    user(username).run_action(:create)
-    # TODO: User shouldn't exist
-  end
-
-  def remove_user(username)
-    user(username).run_action(:remove)
-    # TODO: User shouldn't exist
-  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
-
-    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
-
-    before(:each) do
-      create_group
-    end
-
-    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
-        remove_user("spec-Eric")
-        remove_user("spec-Gordon")
-      end
-
-      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
-
-    describe "when append is set" do
-      before(:each) do
-        group_resource.append(true)
-      end
-
-      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
-
-  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
-
-    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
-
-  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
-
-    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
-
-  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
-
-    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
-
-    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
-

data/spec/functional/resource/user/dscl_spec.rb

@@ -1,199 +0,0 @@
-#
-# Copyright:: Copyright (c) 2014 Chef Software, 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/mixin/shell_out'
-require 'functional/resource/base'
-
-metadata = {
-  :unix_only => true,
-  :requires_root => true,
-  :provider => {:user => Chef::Provider::User::Dscl}
-}
-
-describe "Chef::Resource::User with Chef::Provider::User::Dscl provider", metadata do
-  include Chef::Mixin::ShellOut
-
-  def clean_user
-    begin
-      shell_out!("/usr/bin/dscl . -delete '/Users/#{username}'")
-    rescue Mixlib::ShellOut::ShellCommandFailed
-      # Raised when the user is already cleaned
-    end
-  end
-
-  def user_should_exist
-    shell_out("/usr/bin/dscl . -ls /Users").stdout.should include username
-  end
-
-  def check_password(pass)
-    # In order to test the password we use dscl passwd command since
-    # that's the only command that gets the user password from CLI.
-    shell_out("dscl . -passwd /Users/greatchef #{pass} new_password").exitstatus.should == 0
-    # Now reset the password back
-    shell_out("dscl . -passwd /Users/greatchef new_password #{pass}").exitstatus.should == 0
-  end
-
-  let(:node) do
-    n = Chef::Node.new
-    n.consume_external_attrs(ohai.data.dup, {})
-    n
-  end
-
-  let(:events) do
-    Chef::EventDispatch::Dispatcher.new
-  end
-
-  let(:run_context) do
-    Chef::RunContext.new(node, {}, events)
-  end
-
-  let(:username) do
-    "greatchef"
-  end
-
-  let(:uid) { nil }
-  let(:gid) { 20 }
-  let(:home) { nil }
-  let(:manage_home) { false }
-  let(:password) { "XXXYYYZZZ" }
-  let(:comment) { "Great Chef" }
-  let(:shell) { "/bin/bash" }
-  let(:salt) { nil }
-  let(:iterations) { nil }
-
-  let(:user_resource) do
-    r = Chef::Resource::User.new("TEST USER RESOURCE", run_context)
-    r.username(username)
-    r.uid(uid)
-    r.gid(gid)
-    r.home(home)
-    r.shell(shell)
-    r.comment(comment)
-    r.manage_home(manage_home)
-    r.password(password)
-    r.salt(salt)
-    r.iterations(iterations)
-    r
-  end
-
-  before do
-    clean_user
-  end
-
-  after(:each) do
-    clean_user
-  end
-
-  describe "action :create" do
-    it "should create the user" do
-      user_resource.run_action(:create)
-      user_should_exist
-      check_password(password)
-    end
-  end
-
-  describe "when user exists" do
-    before do
-      existing_resource = user_resource.dup
-      existing_resource.run_action(:create)
-      user_should_exist
-    end
-
-    describe "when password is updated" do
-      it "should update the password of the user" do
-        user_resource.password("mykitchen")
-        user_resource.run_action(:create)
-        check_password("mykitchen")
-      end
-    end
-  end
-
-  describe "when password is being set via shadow hash" do
-    let(:password) {
-      if node[:platform_version].start_with?("10.7.")
-        # On Mac 10.7 we only need to set the password
-        "c9b3bd1a0cde797eef0eff16c580dab996ba3a21961cccc\
-d0f5e65c61558243e50b1a490088bd4824e3b35562d383ca02260398\
-ef1979b302212ec1c5383d1d05fc8d843"
-      else
-        "c734b6e4787c3727bb35e29fdd92b97c\
-1de12df509577a045728255ec7c6c5f5\
-c18efa05ed02b682ffa7ebc05119900e\
-b1d4880833aa7a190afc13e2bf0936b8\
-20123e8c98f0f9bcac2a629d9163caac\
-9464a8c234f3919082400b4f939bb77b\
-c5adbbac718b7eb99463a7b679571e0f\
-1c9fef2ef08d0b9e9c2bcf644eed2ffc"
-      end
-    }
-
-    let(:iterations) { 25000 }
-    let(:salt) { "9e2e7d5ee473b496fd24cf0bbfcaedfcb291ee21740e570d1e917e874f8788ca" }
-
-    it "action :create should create the user" do
-      user_resource.run_action(:create)
-      user_should_exist
-      check_password("soawesome")
-    end
-
-    describe "when user exists" do
-      before do
-        existing_resource = user_resource.dup
-        existing_resource.run_action(:create)
-        user_should_exist
-      end
-
-      describe "when password is updated" do
-        it "should update the password of the user" do
-          user_resource.password("mykitchen")
-          user_resource.run_action(:create)
-          check_password("mykitchen")
-        end
-      end
-    end
-  end
-
-  describe "when a user is member of some groups" do
-    let(:groups) { ["staff", "operator"] }
-
-    before do
-      existing_resource = user_resource.dup
-      existing_resource.run_action(:create)
-
-      groups.each do |group|
-        shell_out!("/usr/bin/dscl . -append '/Groups/#{group}' GroupMembership #{username}")
-      end
-    end
-
-    after do
-      groups.each do |group|
-        # Do not raise an error when user is correctly removed
-        shell_out("/usr/bin/dscl . -delete '/Groups/#{group}' GroupMembership #{username}")
-      end
-    end
-
-    it ":remove action removes the user from the groups and deletes the user"do
-      user_resource.run_action(:remove)
-      groups.each do |group|
-        # Do not raise an error when group is empty
-        shell_out("dscl . read /Groups/staff GroupMembership").stdout.should_not include(group)
-      end
-    end
-  end
-
-end