chef 16.18.30-universal-mingw32 → 17.0.242-universal-mingw32

data/spec/functional/knife/ssh_spec.rb

@@ -1,352 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) 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 "tiny_server"
-
-describe Chef::Knife::Ssh do
-
-  before(:each) do
-    Chef::Knife::Ssh.load_deps
-    @server = TinyServer::Manager.new
-    @server.start
-  end
-
-  after(:each) do
-    @server.stop
-  end
-
-  let(:ssh_config) { {} }
-  before do
-    allow(Net::SSH).to receive(:configuration_for).and_return(ssh_config)
-  end
-
-  describe "identity file" do
-    context "when knife[:ssh_identity_file] is set" do
-      before do
-        Chef::Config[:knife][:ssh_identity_file] = "~/.ssh/aws.rsa"
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "uses the ssh_identity_file" do
-        @knife.run
-        expect(@knife.config[:ssh_identity_file]).to eq("~/.ssh/aws.rsa")
-      end
-    end
-
-    context "when knife[:ssh_identity_file] is set and frozen" do
-      before do
-        Chef::Config[:knife][:ssh_identity_file] = "~/.ssh/aws.rsa".freeze
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "uses the ssh_identity_file" do
-        @knife.run
-        expect(@knife.config[:ssh_identity_file]).to eq("~/.ssh/aws.rsa")
-      end
-    end
-
-    context "when -i is provided" do
-      before do
-        Chef::Config[:knife][:ssh_identity_file] = nil
-        setup_knife(["-i ~/.ssh/aws.rsa", "*:*", "uptime"])
-      end
-
-      it "should use the value on the command line" do
-        @knife.run
-        expect(@knife.config[:ssh_identity_file]).to eq("~/.ssh/aws.rsa")
-      end
-
-      it "should override what is set in knife.rb" do
-        Chef::Config[:knife][:ssh_identity_file] = "~/.ssh/other.rsa"
-        @knife.merge_configs
-        @knife.run
-        expect(@knife.config[:ssh_identity_file]).to eq("~/.ssh/aws.rsa")
-      end
-    end
-
-    context "when knife[:ssh_identity_file] is not provided]" do
-      before do
-        Chef::Config[:knife][:ssh_identity_file] = nil
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "uses the default" do
-        @knife.run
-        expect(@knife.config[:ssh_identity_file]).to eq(nil)
-      end
-    end
-  end
-
-  describe "port" do
-    context "when -p 31337 is provided" do
-      before do
-        setup_knife(["-p 31337", "*:*", "uptime"])
-      end
-
-      it "uses the ssh_port" do
-        @knife.run
-        expect(@knife.config[:ssh_port]).to eq("31337")
-      end
-    end
-  end
-
-  describe "user" do
-    context "when knife[:ssh_user] is set" do
-      before do
-        Chef::Config[:knife][:ssh_user] = "ubuntu"
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "uses the ssh_user" do
-        @knife.run
-        expect(@knife.config[:ssh_user]).to eq("ubuntu")
-      end
-    end
-
-    context "when knife[:ssh_user] is set and frozen" do
-      before do
-        Chef::Config[:knife][:ssh_user] = "ubuntu".freeze
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "uses the ssh_user" do
-        @knife.run
-        expect(@knife.config[:ssh_user]).to eq("ubuntu")
-      end
-    end
-
-    context "when -x is provided" do
-      before do
-        Chef::Config[:knife][:ssh_user] = nil
-        setup_knife(["-x ubuntu", "*:*", "uptime"])
-      end
-
-      it "should use the value on the command line" do
-        @knife.run
-        expect(@knife.config[:ssh_user]).to eq("ubuntu")
-      end
-
-      it "should override what is set in knife.rb" do
-        Chef::Config[:knife][:ssh_user] = "root"
-        @knife.merge_configs
-        @knife.run
-        expect(@knife.config[:ssh_user]).to eq("ubuntu")
-      end
-    end
-
-    context "when knife[:ssh_user] is not provided]" do
-      before do
-        Chef::Config[:knife][:ssh_user] = nil
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "uses the default (current user)" do
-        @knife.run
-        expect(@knife.config[:ssh_user]).to eq(nil)
-      end
-    end
-  end
-
-  describe "attribute" do
-    context "when knife[:ssh_attribute] is set" do
-      before do
-        Chef::Config[:knife][:ssh_attribute] = "ec2.public_hostname"
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "uses the ssh_attribute" do
-        @knife.run
-        expect(@knife.get_ssh_attribute({ "target" => "ec2.public_hostname" })).to eq("ec2.public_hostname")
-      end
-    end
-
-    context "when knife[:ssh_attribute] is not provided" do
-      before do
-        Chef::Config[:knife][:ssh_attribute] = nil
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "uses the default" do
-        @knife.run
-        expect(@knife.get_ssh_attribute({ "fqdn" => "fqdn" })).to eq("fqdn")
-      end
-    end
-
-    context "when -a ec2.public_public_hostname is provided" do
-      before do
-        Chef::Config[:knife][:ssh_attribute] = nil
-        setup_knife(["-a", "ec2.public_hostname", "*:*", "uptime"])
-      end
-
-      it "should use the value on the command line" do
-        @knife.run
-        expect(@knife.config[:ssh_attribute]).to eq("ec2.public_hostname")
-      end
-
-      it "should override what is set in knife.rb" do
-        # This is the setting imported from knife.rb
-        Chef::Config[:knife][:ssh_attribute] = "fqdn"
-        @knife.merge_configs
-        # Then we run knife with the -a flag, which sets the above variable
-        setup_knife(["-a", "ec2.public_hostname", "*:*", "uptime"])
-        @knife.run
-        expect(@knife.config[:ssh_attribute]).to eq("ec2.public_hostname")
-      end
-    end
-  end
-
-  describe "prefix" do
-    context "when knife[:prefix_attribute] is set" do
-      before do
-        Chef::Config[:knife][:prefix_attribute] = "name"
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "uses the prefix_attribute" do
-        @knife.run
-        expect(@knife.get_prefix_attribute({ "prefix" => "name" })).to eq("name")
-      end
-    end
-
-    context "when knife[:prefix_attribute] is not provided" do
-      before do
-        Chef::Config[:knife][:prefix_attribute] = nil
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "falls back to nil" do
-        @knife.run
-        expect(@knife.get_prefix_attribute({})).to eq(nil)
-      end
-    end
-
-    context "when --prefix-attribute ec2.public_public_hostname is provided" do
-      before do
-        Chef::Config[:knife][:prefix_attribute] = nil
-        setup_knife(["--prefix-attribute", "ec2.public_hostname", "*:*", "uptime"])
-      end
-
-      it "should use the value on the command line" do
-        @knife.run
-        expect(@knife.config[:prefix_attribute]).to eq("ec2.public_hostname")
-      end
-
-      it "should override what is set in knife.rb" do
-        # This is the setting imported from knife.rb
-        Chef::Config[:knife][:prefix_attribute] = "fqdn"
-        @knife.merge_configs
-        # Then we run knife with the -b flag, which sets the above variable
-        setup_knife(["--prefix-attribute", "ec2.public_hostname", "*:*", "uptime"])
-        @knife.run
-        expect(@knife.config[:prefix_attribute]).to eq("ec2.public_hostname")
-      end
-    end
-  end
-
-  describe "gateway" do
-    context "when knife[:ssh_gateway] is set" do
-      before do
-        Chef::Config[:knife][:ssh_gateway] = "user@ec2.public_hostname"
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "uses the ssh_gateway" do
-        expect(@knife.session).to receive(:via).with("ec2.public_hostname", "user", { append_all_supported_algorithms: true })
-        @knife.run
-        expect(@knife.config[:ssh_gateway]).to eq("user@ec2.public_hostname")
-      end
-    end
-
-    context "when -G user@ec2.public_hostname is provided" do
-      before do
-        Chef::Config[:knife][:ssh_gateway] = nil
-        setup_knife(["-G user@ec2.public_hostname", "*:*", "uptime"])
-      end
-
-      it "uses the ssh_gateway" do
-        expect(@knife.session).to receive(:via).with("ec2.public_hostname", "user", { append_all_supported_algorithms: true })
-        @knife.run
-        expect(@knife.config[:ssh_gateway]).to eq("user@ec2.public_hostname")
-      end
-    end
-
-    context "when knife[:ssh_gateway_identity] is set" do
-      before do
-        Chef::Config[:knife][:ssh_gateway] = "user@ec2.public_hostname"
-        Chef::Config[:knife][:ssh_gateway_identity] = "~/.ssh/aws-gateway.rsa"
-        setup_knife(["*:*", "uptime"])
-      end
-
-      it "uses the ssh_gateway_identity file" do
-        expect(@knife.session).to receive(:via).with("ec2.public_hostname", "user", { append_all_supported_algorithms: true, keys: File.expand_path("#{ENV["HOME"]}/.ssh/aws-gateway.rsa").squeeze("/"), keys_only: true })
-        @knife.run
-        expect(@knife.config[:ssh_gateway_identity]).to eq("~/.ssh/aws-gateway.rsa")
-      end
-    end
-
-    context "when -ssh-gateway-identity is provided and knife[:ssh_gateway] is set" do
-      before do
-        Chef::Config[:knife][:ssh_gateway] = "user@ec2.public_hostname"
-        Chef::Config[:knife][:ssh_gateway_identity] = nil
-        setup_knife(["--ssh-gateway-identity", "~/.ssh/aws-gateway.rsa", "*:*", "uptime"])
-      end
-
-      it "uses the ssh_gateway_identity file" do
-        expect(@knife.session).to receive(:via).with("ec2.public_hostname", "user", { append_all_supported_algorithms: true, keys: File.expand_path("#{ENV["HOME"]}/.ssh/aws-gateway.rsa").squeeze("/"), keys_only: true })
-        @knife.run
-        expect(@knife.config[:ssh_gateway_identity]).to eq("~/.ssh/aws-gateway.rsa")
-      end
-    end
-
-    context "when the gateway requires a password" do
-      before do
-        Chef::Config[:knife][:ssh_gateway] = nil
-        setup_knife(["-G user@ec2.public_hostname", "*:*", "uptime"])
-        allow(@knife.session).to receive(:via) do |host, user, options|
-          raise Net::SSH::AuthenticationFailed unless options[:password]
-        end
-      end
-
-      it "should prompt the user for a password" do
-        expect(@knife.ui).to receive(:ask).with("Enter the password for user@ec2.public_hostname: ", echo: false).and_return("password")
-        @knife.run
-      end
-    end
-  end
-
-  def setup_knife(params = [])
-    @knife = Chef::Knife::Ssh.new(params)
-    # We explicitly avoid running #configure_chef, which would read a knife.rb
-    # if available, but #merge_configs (which is called by #configure_chef) is
-    # necessary to have default options merged in.
-    @knife.merge_configs
-    allow(@knife).to receive(:ssh_command) { 0 }
-    @api = TinyServer::API.instance
-    @api.clear
-
-    Chef::Config[:node_name] = nil
-    Chef::Config[:client_key] = nil
-    Chef::Config[:chef_server_url] = "http://localhost:9000"
-
-    @api.post("/search/node?q=*:*&start=0&rows=1000", 200) do
-      %({"total":1, "start":0, "rows":[{"data": {"fqdn":"the.fqdn", "target": "the_public_hostname"}}]})
-    end
-  end
-
-end

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

@@ -1,188 +0,0 @@
-#
-# Copyright:: Copyright (c) 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"
-
-metadata = {
-  macos_1013: true,
-  requires_root: true,
-}
-
-describe "Chef::Resource::User with Chef::Provider::User::Dscl provider", metadata do
-  include Chef::Mixin::ShellOut
-
-  def clean_user
-    shell_out!("/usr/bin/dscl . -delete '/Users/#{username}'")
-  rescue Mixlib::ShellOut::ShellCommandFailed
-    # Raised when the user is already cleaned
-  end
-
-  def user_should_exist
-    expect(shell_out("/usr/bin/dscl . -ls /Users").stdout).to 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.
-    expect(shell_out("dscl . -passwd /Users/greatchef #{pass} new_password").exitstatus).to eq(0)
-    # Now reset the password back
-    expect(shell_out("dscl . -passwd /Users/greatchef new_password #{pass}").exitstatus).to eq(0)
-  end
-
-  let(:node) do
-    n = Chef::Node.new
-    n.consume_external_attrs(OHAI_SYSTEM.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::DsclUser.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) do
-      "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) { %w{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
-        expect(shell_out("dscl . read /Groups/staff GroupMembership").stdout).not_to include(group)
-      end
-    end
-  end
-
-end

data/spec/functional/resource/windows_service_spec.rb

@@ -1,105 +0,0 @@
-#
-# Author:: Chris Doherty (<cdoherty@chef.io>)
-# Copyright:: Copyright (c) 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"
-
-describe Chef::Resource::WindowsService, :windows_only, :system_windows_service_gem_only do
-
-  include_context "using Win32::Service"
-
-  let(:username) { "service_spec_user" }
-  let(:qualified_username) { "#{ENV["COMPUTERNAME"]}\\#{username}" }
-  let(:password) { "1a2b3c4X!&narf" }
-
-  let(:user_resource) do
-    r = Chef::Resource::User::WindowsUser.new(username, run_context)
-    r.username(username)
-    r.password(password)
-    r.comment("temp spec user")
-    r
-  end
-
-  let(:global_service_file_path) do
-    "#{ENV["WINDIR"]}\\temp\\#{File.basename(test_service[:service_file_path])}"
-  end
-
-  let(:service_params) do
-
-    id = "#{$$}_#{rand(1000)}"
-
-    test_service.merge( {
-      run_as_user: qualified_username,
-      run_as_password: password,
-      service_name: "spec_service_#{id}",
-      service_display_name: "windows_service spec #{id}}",
-      service_description: "Test service for running the windows_service functional spec.",
-      service_file_path: global_service_file_path,
-      } )
-  end
-
-  let(:manager) do
-    Chef::Application::WindowsServiceManager.new(service_params)
-  end
-
-  let(:service_resource) do
-    r = Chef::Resource::WindowsService.new(service_params[:service_name], run_context)
-    %i{run_as_user run_as_password}.each { |prop| r.send(prop, service_params[prop]) }
-    r
-  end
-
-  let(:run_context) do
-    Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
-  end
-
-  before do
-    user_resource.run_action(:create)
-
-    # the service executable has to be outside the current user's home
-    # directory in order for the logon user to execute it.
-    FileUtils.copy_file(test_service[:service_file_path], global_service_file_path)
-
-    # if you don't make the file executable by the service user, you'll get
-    # the not-very-helpful "service did not respond fast enough" error.
-
-    # #mode may break in a post-Windows 8.1 release, and have to be replaced
-    # with the rights stuff in the file resource.
-    file = Chef::Resource::File.new(global_service_file_path, run_context)
-    file.mode("0777")
-
-    file.run_action(:create)
-
-    manager.run(%w{--action install})
-  end
-
-  after do
-    user_resource.run_action(:remove)
-    manager.run(%w{--action uninstall})
-    File.delete(global_service_file_path)
-  end
-
-  describe "logon as a service" do
-    it "successfully runs a service as another user" do
-      service_resource.run_action(:start)
-    end
-
-    it "grants the user the log on as service right" do
-      service_resource.run_action(:start)
-      expect(Chef::ReservedNames::Win32::Security.get_account_right(qualified_username)).to include("SeServiceLogonRight")
-    end
-  end
-end