chef 16.11.7 → 17.2.29

data/spec/unit/cookbook_site_streaming_uploader_spec.rb

@@ -1,198 +0,0 @@
-#
-# Author:: Xabier de Zuazo (xabier@onddo.com)
-# Copyright:: Copyright 2013-2016, Onddo Labs, SL.
-# 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/cookbook_site_streaming_uploader"
-
-class FakeTempfile
-  def initialize(basename)
-    @basename = basename
-  end
-
-  def close; end
-
-  def path
-    "#{@basename}.ZZZ"
-  end
-
-end
-
-describe Chef::CookbookSiteStreamingUploader do
-
-  describe "create_build_dir" do
-
-    before(:each) do
-      @cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
-      @loader = Chef::CookbookLoader.new(@cookbook_repo)
-      @loader.load_cookbooks
-      allow(File).to receive(:unlink)
-    end
-
-    it "should create the cookbook tmp dir" do
-      cookbook = @loader[:openldap]
-      files_count = Dir.glob(File.join(@cookbook_repo, cookbook.name.to_s, "**", "*"), File::FNM_DOTMATCH).count { |file| File.file?(file) }
-
-      expect(Tempfile).to receive(:new).with("chef-#{cookbook.name}-build").and_return(FakeTempfile.new("chef-#{cookbook.name}-build"))
-      expect(FileUtils).to receive(:mkdir_p).exactly(files_count + 1).times
-      expect(FileUtils).to receive(:cp).exactly(files_count).times
-      Chef::CookbookSiteStreamingUploader.create_build_dir(cookbook)
-    end
-
-  end # create_build_dir
-
-  describe "make_request" do
-
-    before(:each) do
-      @uri = "http://cookbooks.dummy.com/api/v1/cookbooks"
-      @secret_filename = File.join(CHEF_SPEC_DATA, "ssl/private_key.pem")
-      @rsa_key = File.read(@secret_filename)
-      response = Net::HTTPResponse.new("1.0", "200", "OK")
-      allow_any_instance_of(Net::HTTP).to receive(:request).and_return(response)
-    end
-
-    it "should send an http request" do
-      expect_any_instance_of(Net::HTTP).to receive(:request)
-      Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, "bill", @secret_filename)
-    end
-
-    it "should read the private key file" do
-      expect(File).to receive(:read).with(@secret_filename).and_return(@rsa_key)
-      Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, "bill", @secret_filename)
-    end
-
-    it "should add the authentication signed header" do
-      expect_any_instance_of(Mixlib::Authentication::SigningObject).to receive(:sign).and_return({})
-      Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, "bill", @secret_filename)
-    end
-
-    it "should be able to send post requests" do
-      post = Net::HTTP::Post.new(@uri, {})
-
-      expect(Net::HTTP::Post).to receive(:new).once.and_return(post)
-      expect(Net::HTTP::Put).not_to receive(:new)
-      expect(Net::HTTP::Get).not_to receive(:new)
-      Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, "bill", @secret_filename)
-    end
-
-    it "should be able to send put requests" do
-      put = Net::HTTP::Put.new(@uri, {})
-
-      expect(Net::HTTP::Post).not_to receive(:new)
-      expect(Net::HTTP::Put).to receive(:new).once.and_return(put)
-      expect(Net::HTTP::Get).not_to receive(:new)
-      Chef::CookbookSiteStreamingUploader.make_request(:put, @uri, "bill", @secret_filename)
-    end
-
-    it "should be able to receive files to attach as argument" do
-      Chef::CookbookSiteStreamingUploader.make_request(:put, @uri, "bill", @secret_filename, {
-        myfile: File.new(File.join(CHEF_SPEC_DATA, "config.rb")), # a dummy file
-      })
-    end
-
-    it "should be able to receive strings to attach as argument" do
-      Chef::CookbookSiteStreamingUploader.make_request(:put, @uri, "bill", @secret_filename, {
-        mystring: "Lorem ipsum",
-      })
-    end
-
-    it "should be able to receive strings and files as argument at the same time" do
-      Chef::CookbookSiteStreamingUploader.make_request(:put, @uri, "bill", @secret_filename, {
-        myfile1: File.new(File.join(CHEF_SPEC_DATA, "config.rb")),
-        mystring1: "Lorem ipsum",
-        myfile2: File.new(File.join(CHEF_SPEC_DATA, "config.rb")),
-        mystring2: "Dummy text",
-      })
-    end
-
-  end # make_request
-
-  describe "StreamPart" do
-    before(:each) do
-      @file = File.new(File.join(CHEF_SPEC_DATA, "config.rb"))
-      @stream_part = Chef::CookbookSiteStreamingUploader::StreamPart.new(@file, File.size(@file))
-    end
-
-    it "should create a StreamPart" do
-      expect(@stream_part).to be_instance_of(Chef::CookbookSiteStreamingUploader::StreamPart)
-    end
-
-    it "should expose its size" do
-      expect(@stream_part.size).to eql(File.size(@file))
-    end
-
-    it "should read with offset and how_much" do
-      content = @file.read(4)
-      @file.rewind
-      expect(@stream_part.read(0, 4)).to eql(content)
-    end
-
-  end # StreamPart
-
-  describe "StringPart" do
-    before(:each) do
-      @str = "What a boring string"
-      @string_part = Chef::CookbookSiteStreamingUploader::StringPart.new(@str)
-    end
-
-    it "should create a StringPart" do
-      expect(@string_part).to be_instance_of(Chef::CookbookSiteStreamingUploader::StringPart)
-    end
-
-    it "should expose its size" do
-      expect(@string_part.size).to eql(@str.size)
-    end
-
-    it "should read with offset and how_much" do
-      expect(@string_part.read(2, 4)).to eql(@str[2, 4])
-    end
-
-  end # StringPart
-
-  describe "MultipartStream" do
-    before(:each) do
-      @string1 = "stream1"
-      @string2 = "stream2"
-      @stream1 = Chef::CookbookSiteStreamingUploader::StringPart.new(@string1)
-      @stream2 = Chef::CookbookSiteStreamingUploader::StringPart.new(@string2)
-      @parts = [ @stream1, @stream2 ]
-
-      @multipart_stream = Chef::CookbookSiteStreamingUploader::MultipartStream.new(@parts)
-    end
-
-    it "should create a MultipartStream" do
-      expect(@multipart_stream).to be_instance_of(Chef::CookbookSiteStreamingUploader::MultipartStream)
-    end
-
-    it "should expose its size" do
-      expect(@multipart_stream.size).to eql(@stream1.size + @stream2.size)
-    end
-
-    it "should read with how_much" do
-      expect(@multipart_stream.read(10)).to eql("#{@string1}#{@string2}"[0, 10])
-    end
-
-    it "should read receiving destination buffer as second argument (CHEF-4456: Ruby 2 compat)" do
-      dst_buf = ""
-      @multipart_stream.read(10, dst_buf)
-      expect(dst_buf).to eql("#{@string1}#{@string2}"[0, 10])
-    end
-
-  end # MultipartStream
-
-end

data/spec/unit/knife/bootstrap/chef_vault_handler_spec.rb

@@ -1,152 +0,0 @@
-#
-# Author:: Lamont Granquist <lamont@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::Knife::Bootstrap::ChefVaultHandler do
-
-  let(:stdout) { StringIO.new }
-  let(:stderr) { StringIO.new }
-  let(:stdin) { StringIO.new }
-  let(:ui) { Chef::Knife::UI.new(stdout, stderr, stdin, {}) }
-
-  let(:config) { {} }
-
-  let(:client) { Chef::ApiClient.new }
-
-  let(:chef_vault_handler) do
-    chef_vault_handler = Chef::Knife::Bootstrap::ChefVaultHandler.new(config: config, ui: ui)
-    chef_vault_handler
-  end
-
-  context "when there's no vault option" do
-    it "should report its not doing anything" do
-      expect(chef_vault_handler.doing_chef_vault?).to be false
-    end
-
-    it "shouldn't do anything" do
-      expect(chef_vault_handler).to_not receive(:sanity_check)
-      expect(chef_vault_handler).to_not receive(:update_bootstrap_vault_json!)
-      chef_vault_handler
-    end
-  end
-
-  context "when setting chef vault items" do
-    let(:bootstrap_vault_item) { double("ChefVault::Item") }
-
-    before do
-      expect(chef_vault_handler).to receive(:require_chef_vault!).at_least(:once)
-      expect(bootstrap_vault_item).to receive(:clients).with(client).at_least(:once)
-      expect(bootstrap_vault_item).to receive(:save).at_least(:once)
-    end
-
-    context "from config[:bootstrap_vault_item]" do
-      it "sets a single item as a scalar" do
-        config[:bootstrap_vault_item] = { "vault" => "item1" }
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-
-      it "sets a single item as an array" do
-        config[:bootstrap_vault_item] = { "vault" => [ "item1" ] }
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-
-      it "sets two items as an array" do
-        config[:bootstrap_vault_item] = { "vault" => %w{item1 item2} }
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-
-      it "sets two vaults from different hash keys" do
-        config[:bootstrap_vault_item] = { "vault" => %w{item1 item2}, "vault2" => [ "item3" ] }
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault2", "item3").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-    end
-
-    context "from config[:bootstrap_vault_json]" do
-      it "sets a single item as a scalar" do
-        config[:bootstrap_vault_json] = '{ "vault": "item1" }'
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-
-      it "sets a single item as an array" do
-        config[:bootstrap_vault_json] = '{ "vault": [ "item1" ] }'
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-
-      it "sets two items as an array" do
-        config[:bootstrap_vault_json] = '{ "vault": [ "item1", "item2" ] }'
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-
-      it "sets two vaults from different hash keys" do
-        config[:bootstrap_vault_json] = '{ "vault": [ "item1", "item2" ], "vault2": [ "item3" ] }'
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault2", "item3").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-    end
-
-    context "from config[:bootstrap_vault_file]" do
-
-      def setup_file_contents(json)
-        stringio = StringIO.new(json)
-        config[:bootstrap_vault_file] = "/foo/bar/baz"
-        expect(File).to receive(:read).with(config[:bootstrap_vault_file]).and_return(stringio)
-      end
-
-      it "sets a single item as a scalar" do
-        setup_file_contents('{ "vault": "item1" }')
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-
-      it "sets a single item as an array" do
-        setup_file_contents('{ "vault": [ "item1" ] }')
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-
-      it "sets two items as an array" do
-        setup_file_contents('{ "vault": [ "item1", "item2" ] }')
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-
-      it "sets two vaults from different hash keys" do
-        setup_file_contents('{ "vault": [ "item1", "item2" ], "vault2": [ "item3" ] }')
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
-        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault2", "item3").and_return(bootstrap_vault_item)
-        chef_vault_handler.run(client)
-      end
-    end
-  end
-end

data/spec/unit/knife/bootstrap/client_builder_spec.rb

@@ -1,207 +0,0 @@
-#
-# Author:: Lamont Granquist <lamont@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::Knife::Bootstrap::ClientBuilder do
-
-  let(:stdout) { StringIO.new }
-  let(:stderr) { StringIO.new }
-  let(:stdin) { StringIO.new }
-  let(:ui) { Chef::Knife::UI.new(stdout, stderr, stdin, {}) }
-
-  let(:config) { {} }
-
-  let(:chef_config) { {} }
-
-  let(:node_name) { "bevell.wat" }
-
-  let(:rest) { double("Chef::ServerAPI") }
-
-  let(:client_builder) do
-    client_builder = Chef::Knife::Bootstrap::ClientBuilder.new(config: config, chef_config: chef_config, ui: ui)
-    allow(client_builder).to receive(:rest).and_return(rest)
-    allow(client_builder).to receive(:node_name).and_return(node_name)
-    client_builder
-  end
-
-  context "#sanity_check!" do
-    let(:response_404) { OpenStruct.new(code: "404") }
-    let(:exception_404) { Net::HTTPClientException.new("404 not found", response_404) }
-
-    context "in cases where the prompting fails" do
-      before do
-        # should fail early in #run
-        expect(client_builder).to_not receive(:create_client!)
-        expect(client_builder).to_not receive(:create_node!)
-      end
-
-      it "exits when the node exists and the user does not want to delete" do
-        expect(rest).to receive(:get).with("nodes/#{node_name}")
-        expect(ui.stdin).to receive(:readline).and_return("n")
-        expect { client_builder.run }.to raise_error(SystemExit)
-      end
-
-      it "exits when the client exists and the user does not want to delete" do
-        expect(rest).to receive(:get).with("nodes/#{node_name}").and_raise(exception_404)
-        expect(rest).to receive(:get).with("clients/#{node_name}")
-        expect(ui.stdin).to receive(:readline).and_return("n")
-        expect { client_builder.run }.to raise_error(SystemExit)
-      end
-    end
-
-    context "in cases where the prompting succeeds" do
-      before do
-        # mock out the rest of #run
-        expect(client_builder).to receive(:create_client!)
-        expect(client_builder).to receive(:create_node!)
-      end
-
-      it "when both the client and node do not exist it succeeds" do
-        expect(rest).to receive(:get).with("nodes/#{node_name}").and_raise(exception_404)
-        expect(rest).to receive(:get).with("clients/#{node_name}").and_raise(exception_404)
-        expect { client_builder.run }.not_to raise_error
-      end
-
-      it "when we are allowed to delete an old node" do
-        expect(rest).to receive(:get).with("nodes/#{node_name}")
-        expect(ui.stdin).to receive(:readline).and_return("y")
-        expect(rest).to receive(:get).with("clients/#{node_name}").and_raise(exception_404)
-        expect(rest).to receive(:delete).with("nodes/#{node_name}")
-        expect { client_builder.run }.not_to raise_error
-      end
-
-      it "when we are allowed to delete an old client" do
-        expect(rest).to receive(:get).with("nodes/#{node_name}").and_raise(exception_404)
-        expect(rest).to receive(:get).with("clients/#{node_name}")
-        expect(ui.stdin).to receive(:readline).and_return("y")
-        expect(rest).to receive(:delete).with("clients/#{node_name}")
-        expect { client_builder.run }.not_to raise_error
-      end
-
-      it "when we are are allowed to delete both an old client and node" do
-        expect(rest).to receive(:get).with("nodes/#{node_name}")
-        expect(rest).to receive(:get).with("clients/#{node_name}")
-        expect(ui.stdin).to receive(:readline).twice.and_return("y")
-        expect(rest).to receive(:delete).with("nodes/#{node_name}")
-        expect(rest).to receive(:delete).with("clients/#{node_name}")
-        expect { client_builder.run }.not_to raise_error
-      end
-    end
-  end
-
-  context "#create_client!" do
-    let(:client) { Chef::ApiClient.new }
-
-    before do
-      # mock out the rest of #run
-      expect(client_builder).to receive(:sanity_check)
-      expect(client_builder).to receive(:create_node!)
-    end
-
-    it "delegates everything to Chef::ApiClient::Registration and sets client" do
-      reg_double = double("Chef::ApiClient::Registration")
-      expect(Chef::ApiClient::Registration).to receive(:new).with(node_name, client_builder.client_path, http_api: rest).and_return(reg_double)
-      expect(reg_double).to receive(:run).and_return(client)
-      client_builder.run
-      expect(client_builder.client).to eq(client)
-    end
-
-  end
-
-  context "#client_path" do
-    it "has a public API for the temporary client.pem file" do
-      expect(client_builder.client_path).to match(/#{node_name}.pem/)
-    end
-  end
-
-  context "#create_node!" do
-    before do
-      # mock out the rest of #run
-      expect(client_builder).to receive(:sanity_check)
-      expect(client_builder).to receive(:create_client!)
-      # mock out default node building steps
-      expect(client_builder).to receive(:client_rest).and_return(client_rest)
-      expect(Chef::Node).to receive(:new).with(chef_server_rest: client_rest).and_return(node)
-      expect(node).to receive(:name).with(node_name)
-      expect(node).to receive(:save)
-    end
-
-    let(:client_rest) { double("Chef::ServerAPI (client)") }
-
-    let(:node) { double("Chef::Node") }
-
-    it "builds a node with a default run_list of []" do
-      expect(node).to receive(:run_list).with([])
-      client_builder.run
-    end
-
-    it "does not add tags by default" do
-      allow(node).to receive(:run_list).with([])
-      expect(node).to_not receive(:tags)
-      client_builder.run
-    end
-
-    it "adds tags to the node when given" do
-      tag_receiver = []
-
-      config[:tags] = %w{foo bar}
-      allow(node).to receive(:run_list).with([])
-      allow(node).to receive(:tags).and_return(tag_receiver)
-      client_builder.run
-      expect(tag_receiver).to eq %w{foo bar}
-    end
-
-    it "builds a node when the run_list is a string" do
-      config[:run_list] = "role[base],role[app]"
-      expect(node).to receive(:run_list).with(["role[base]", "role[app]"])
-      client_builder.run
-    end
-
-    it "builds a node when the run_list is an Array" do
-      config[:run_list] = ["role[base]", "role[app]"]
-      expect(node).to receive(:run_list).with(["role[base]", "role[app]"])
-      client_builder.run
-    end
-
-    it "builds a node with first_boot_attributes if they're given" do
-      config[:first_boot_attributes] = { baz: :quux }
-      expect(node).to receive(:normal_attrs=).with({ baz: :quux })
-      expect(node).to receive(:run_list).with([])
-      client_builder.run
-    end
-
-    it "builds a node with an environment if its given" do
-      config[:environment] = "production"
-      expect(node).to receive(:environment).with("production")
-      expect(node).to receive(:run_list).with([])
-      client_builder.run
-    end
-
-    it "builds a node with policy_name and policy_group when given" do
-      config[:policy_name] = "my-app"
-      config[:policy_group] = "staging"
-
-      expect(node).to receive(:run_list).with([])
-      expect(node).to receive(:policy_name=).with("my-app")
-      expect(node).to receive(:policy_group=).with("staging")
-
-      client_builder.run
-    end
-  end
-end