chef 16.10.8-universal-mingw32 → 17.0.242-universal-mingw32

data/spec/functional/knife/smoke_test.rb

@@ -1,42 +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"
-
-describe "knife smoke tests" do
-
-  # Since our specs load all code, there could be a case where knife does not
-  # run correctly b/c of a missing require, but is not caught by other tests.
-  #
-  # We run `knife -v` to verify that knife at least loads all its code.
-  it "can run and print its version" do
-    knife_path = File.expand_path("../../bin/knife", CHEF_SPEC_DATA)
-    knife_cmd = Mixlib::ShellOut.new("#{knife_path} -v")
-    knife_cmd.run_command
-    knife_cmd.error!
-    expect(knife_cmd.stdout).to include(Chef::VERSION)
-  end
-
-  it "can run and show help" do
-    knife_path = File.expand_path("../../bin/knife", CHEF_SPEC_DATA)
-    knife_cmd = Mixlib::ShellOut.new("#{knife_path} --help")
-    knife_cmd.run_command
-    knife_cmd.error!
-    expect(knife_cmd.stdout).to include("Usage")
-  end
-end

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