chef 16.13.16-universal-mingw32 → 17.0.242-universal-mingw32

data/spec/unit/knife/cookbook_list_spec.rb

@@ -1,88 +0,0 @@
-#
-# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
-# Copyright:: Copyright 2011-2016, Thomas Bishop
-# 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::CookbookList do
-  before do
-    @knife = Chef::Knife::CookbookList.new
-    @rest_mock = double("rest")
-    allow(@knife).to receive(:rest).and_return(@rest_mock)
-    @cookbook_names = %w{apache2 mysql}
-    @base_url = "https://server.example.com/cookbooks"
-    @cookbook_data = {}
-    @cookbook_names.each do |item|
-      @cookbook_data[item] = { "url" => "#{@base_url}/#{item}",
-                               "versions" => [{ "version" => "1.0.1",
-                                                "url" => "#{@base_url}/#{item}/1.0.1" }] }
-    end
-    @stdout = StringIO.new
-    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
-  end
-
-  describe "run" do
-    it "should display the latest version of the cookbooks" do
-      expect(@rest_mock).to receive(:get).with("/cookbooks?num_versions=1")
-        .and_return(@cookbook_data)
-      @knife.run
-      @cookbook_names.each do |item|
-        expect(@stdout.string).to match(/#{item}\s+1\.0\.1/)
-      end
-    end
-
-    it "should query cookbooks for the configured environment" do
-      @knife.config[:environment] = "production"
-      expect(@rest_mock).to receive(:get)
-        .with("/environments/production/cookbooks?num_versions=1")
-        .and_return(@cookbook_data)
-      @knife.run
-    end
-
-    describe "with -w or --with-uri" do
-      it "should display the cookbook uris" do
-        @knife.config[:with_uri] = true
-        allow(@rest_mock).to receive(:get).and_return(@cookbook_data)
-        @knife.run
-        @cookbook_names.each do |item|
-          pattern = /#{Regexp.escape(@cookbook_data[item]['versions'].first['url'])}/
-          expect(@stdout.string).to match pattern
-        end
-      end
-    end
-
-    describe "with -a or --all" do
-      before do
-        @cookbook_names.each do |item|
-          @cookbook_data[item]["versions"] << { "version" => "1.0.0",
-                                                "url" => "#{@base_url}/#{item}/1.0.0" }
-        end
-      end
-
-      it "should display all versions of the cookbooks" do
-        @knife.config[:all_versions] = true
-        expect(@rest_mock).to receive(:get).with("/cookbooks?num_versions=all")
-          .and_return(@cookbook_data)
-        @knife.run
-        @cookbook_names.each do |item|
-          expect(@stdout.string).to match(/#{item}\s+1\.0\.1\s+1\.0\.0/)
-        end
-      end
-    end
-
-  end
-end

data/spec/unit/knife/cookbook_metadata_from_file_spec.rb

@@ -1,72 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Matthew Kent (<mkent@magoazul.com>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# 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::CookbookMetadataFromFile do
-  before(:each) do
-    Chef::Config[:node_name] = "webmonkey.example.com"
-    @src = File.expand_path(File.join(CHEF_SPEC_DATA, "metadata", "quick_start", "metadata.rb"))
-    @tgt = File.expand_path(File.join(CHEF_SPEC_DATA, "metadata", "quick_start", "metadata.json"))
-    @knife = Chef::Knife::CookbookMetadataFromFile.new
-    @knife.name_args = [ @src ]
-    allow(@knife).to receive(:to_json_pretty).and_return(true)
-    @md = Chef::Cookbook::Metadata.new
-    allow(Chef::Cookbook::Metadata).to receive(:new).and_return(@md)
-    allow($stdout).to receive(:write)
-  end
-
-  after do
-    if File.exist?(@tgt)
-      File.unlink(@tgt)
-    end
-  end
-
-  describe "run" do
-    it "should print usage and exit when a FILE is not provided" do
-      @knife.name_args = []
-      expect(@knife).to receive(:show_usage)
-      expect(@knife.ui).to receive(:fatal).with(/You must specify the FILE./)
-      expect { @knife.run }.to raise_error(SystemExit)
-    end
-
-    it "should determine cookbook name from path" do
-      expect(@md).to receive(:name).with(no_args)
-      expect(@md).to receive(:name).with("quick_start")
-      @knife.run
-    end
-
-    it "should load the metadata source" do
-      expect(@md).to receive(:from_file).with(@src)
-      @knife.run
-    end
-
-    it "should write out the metadata to the correct location" do
-      expect(File).to receive(:open).with(@tgt, "w")
-      @knife.run
-    end
-
-    it "should generate json from the metadata" do
-      expect(Chef::JSONCompat).to receive(:to_json_pretty).with(@md)
-      @knife.run
-    end
-
-  end
-end

data/spec/unit/knife/cookbook_metadata_spec.rb

@@ -1,182 +0,0 @@
-#
-# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
-# Copyright:: Copyright 2011-2016, Thomas Bishop
-# 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::CookbookMetadata do
-  let(:knife) do
-    knife = Chef::Knife::CookbookMetadata.new
-    knife.name_args = ["foobar"]
-    knife
-  end
-
-  let(:cookbook_dir) { Dir.mktmpdir }
-
-  let(:stdout) { StringIO.new }
-
-  let(:stderr) { StringIO.new }
-
-  before(:each) do
-    allow(knife.ui).to receive(:stdout).and_return(stdout)
-    allow(knife.ui).to receive(:stderr).and_return(stderr)
-  end
-
-  def create_metadata_rb(**kwargs)
-    name = kwargs[:name]
-    Dir.mkdir("#{cookbook_dir}/#{name}")
-    File.open("#{cookbook_dir}/#{name}/metadata.rb", "w+") do |f|
-      kwargs.each do |key, value|
-        if value.is_a?(Array)
-          f.puts "#{key} #{value.map { |v| "\"#{v}\"" }.join(", ")}"
-        else
-          f.puts "#{key} \"#{value}\""
-        end
-      end
-    end
-  end
-
-  def create_metadata_json(**kwargs)
-    name = kwargs[:name]
-    Dir.mkdir("#{cookbook_dir}/#{name}")
-    File.open("#{cookbook_dir}/#{name}/metadata.json", "w+") do |f|
-      f.write(FFI_Yajl::Encoder.encode(kwargs))
-    end
-  end
-
-  def create_invalid_json
-    Dir.mkdir("#{cookbook_dir}/foobar")
-    File.open("#{cookbook_dir}/foobar/metadata.json", "w+") do |f|
-      f.write <<-EOH
-      { "version": "1.0.0", {ImInvalid}}
-      EOH
-    end
-  end
-
-  describe "run" do
-    it "should print an error and exit if a cookbook name was not provided" do
-      knife.name_args = []
-      expect(knife.ui).to receive(:error).with(/you must specify the cookbook.+use the --all/i)
-      expect { knife.run }.to raise_error(SystemExit)
-    end
-
-    it "should print an error and exit if an empty cookbook name was provided" do
-      knife.name_args = [""]
-      expect(knife.ui).to receive(:error).with(/you must specify the cookbook.+use the --all/i)
-      expect { knife.run }.to raise_error(SystemExit)
-    end
-
-    it "should generate the metadata for the cookbook" do
-      expect(knife).to receive(:generate_metadata).with("foobar")
-      knife.run
-    end
-
-    describe "with -a or --all" do
-      before(:each) do
-        Chef::Config[:cookbook_path] = cookbook_dir
-        knife.config[:all] = true
-        create_metadata_rb(name: "foo", version: "1.0.0")
-        create_metadata_rb(name: "bar", version: "2.0.0")
-        expect(knife).to receive(:generate_metadata).with("foo").and_call_original
-        expect(knife).to receive(:generate_metadata).with("bar").and_call_original
-      end
-
-      it "should generate the metadata for each cookbook" do
-        expect(Chef::CookbookLoader).to receive(:new).with(cookbook_dir).and_call_original
-        knife.run
-        expect(stderr.string).to match %r{generating metadata for foo from #{cookbook_dir}/foo/metadata\.rb}im
-        expect(stderr.string).to match %r{generating metadata for bar from #{cookbook_dir}/bar/metadata\.rb}im
-      end
-
-      it "with -o or --cookbook_path should look in the provided path and generate cookbook metadata" do
-        Chef::Config[:cookbook_path] = "/dev/null"
-        knife.config[:cookbook_path] = cookbook_dir
-        expect(Chef::CookbookLoader).to receive(:new).with(cookbook_dir).and_call_original
-        knife.run
-        expect(stderr.string).to match %r{generating metadata for foo from #{cookbook_dir}/foo/metadata\.rb}im
-        expect(stderr.string).to match %r{generating metadata for bar from #{cookbook_dir}/bar/metadata\.rb}im
-      end
-    end
-
-  end
-
-  describe "generate_metadata" do
-    before(:each) do
-      Chef::Config[:cookbook_path] = cookbook_dir
-    end
-
-    it "should generate the metadata from metadata.rb if it exists" do
-      create_metadata_rb(name: "foobar", version: "1.0.0")
-      expect(knife).to receive(:generate_metadata_from_file).with("foobar", "#{cookbook_dir}/foobar/metadata.rb").and_call_original
-      knife.run
-      expect(File.exist?("#{cookbook_dir}/foobar/metadata.json")).to be true
-      json = FFI_Yajl::Parser.parse(IO.read("#{cookbook_dir}/foobar/metadata.json"))
-      expect(json["name"]).to eql("foobar")
-      expect(json["version"]).to eql("1.0.0")
-    end
-
-    it "should validate the metadata json if metadata.rb does not exist" do
-      create_metadata_json(name: "foobar", version: "1.0.0")
-      expect(knife).to receive(:validate_metadata_json).with(cookbook_dir, "foobar").and_call_original
-      knife.run
-    end
-  end
-
-  describe "validation errors" do
-    before(:each) do
-      Chef::Config[:cookbook_path] = cookbook_dir
-    end
-
-    it "should fail for obsolete operators in metadata.rb" do
-      create_metadata_rb(name: "foobar", version: "1.0.0", depends: [ "foo:bar", ">> 0.2" ])
-      expect(Chef::Cookbook::Metadata).not_to receive(:validate_json)
-      expect { knife.run }.to raise_error(SystemExit)
-      expect(stderr.string).to match(/error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im)
-    end
-
-    it "should fail for obsolete format in metadata.rb (sadly)" do
-      create_metadata_rb(name: "foobar", version: "1.0.0", depends: [ "foo:bar", "> 0.2", "< 1.0" ])
-      expect(Chef::Cookbook::Metadata).not_to receive(:validate_json)
-      expect { knife.run }.to raise_error(SystemExit)
-      expect(stderr.string).to match(/error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im)
-    end
-
-    it "should fail for obsolete operators in metadata.json" do
-      create_metadata_json(name: "foobar", version: "1.0.0", dependencies: { "foo:bar" => ">> 0.2" })
-      expect { knife.run }.to raise_error(SystemExit)
-      expect(stderr.string).to match(/error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im)
-    end
-
-    it "should not fail for unknown field in metadata.rb" do
-      create_metadata_rb(name: "sounders", version: "2.0.0", beats: "toronto")
-      expect(Chef::Cookbook::Metadata).not_to receive(:validate_json)
-      expect { knife.run }.not_to raise_error
-      expect(stderr.string).to eql("")
-    end
-
-    it "should not fail for unknown field in metadata.json" do
-      create_metadata_json(name: "sounders", version: "2.0.0", beats: "toronto")
-      expect { knife.run }.not_to raise_error
-      expect(stderr.string).to eql("")
-    end
-
-    it "should fail on unparsable json" do
-      create_invalid_json
-      expect { knife.run }.to raise_error(Chef::Exceptions::JSON::ParseError)
-    end
-  end
-end

data/spec/unit/knife/cookbook_show_spec.rb

@@ -1,253 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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::CookbookShow do
-  before do
-    Chef::Config[:node_name] = "webmonkey.example.com"
-    allow(knife).to receive(:rest).and_return(rest)
-    allow(knife).to receive(:pretty_print).and_return(true)
-    allow(knife).to receive(:output).and_return(true)
-    allow(Chef::CookbookVersion).to receive(:load).and_return(cb)
-  end
-
-  let(:knife) do
-    knife = Chef::Knife::CookbookShow.new
-    knife.config = {}
-    knife.name_args = [ "cookbook_name" ]
-    knife
-  end
-
-  let(:cb) do
-    cb = Chef::CookbookVersion.new("cookbook_name")
-    cb.manifest = manifest
-    cb
-  end
-
-  let(:rest) { double(Chef::ServerAPI) }
-
-  let(:content) { "Example recipe text" }
-
-  let(:manifest) do
-    {
-      "all_files" => [
-        {
-          name: "recipes/default.rb",
-          path: "recipes/default.rb",
-          checksum: "1234",
-          url: "http://example.org/files/default.rb",
-        },
-      ],
-    }
-  end
-
-  describe "run" do
-    describe "with 0 arguments: help" do
-      it "should should print usage and exit when given no arguments" do
-        knife.name_args = []
-        expect(knife).to receive(:show_usage)
-        expect(knife.ui).to receive(:fatal)
-        expect { knife.run }.to raise_error(SystemExit)
-      end
-    end
-
-    describe "with 1 argument: versions" do
-      let(:response) do
-        {
-          "cookbook_name" => {
-            "url" => "http://url/cookbooks/cookbook_name",
-            "versions" => [
-              { "version" => "0.10.0", "url" => "http://url/cookbooks/cookbook_name/0.10.0" },
-              { "version" => "0.9.0", "url" => "http://url/cookbookx/cookbook_name/0.9.0" },
-              { "version" => "0.8.0", "url" => "http://url/cookbooks/cookbook_name/0.8.0" },
-            ],
-          },
-        }
-      end
-
-      it "should show the raw cookbook data" do
-        expect(rest).to receive(:get).with("cookbooks/cookbook_name").and_return(response)
-        expect(knife).to receive(:format_cookbook_list_for_display).with(response)
-        knife.run
-      end
-
-      it "should respect the user-supplied environment" do
-        knife.config[:environment] = "foo"
-        expect(rest).to receive(:get).with("environments/foo/cookbooks/cookbook_name").and_return(response)
-        expect(knife).to receive(:format_cookbook_list_for_display).with(response)
-        knife.run
-      end
-    end
-
-    describe "with 2 arguments: name and version" do
-      before do
-        knife.name_args << "0.1.0"
-      end
-
-      let(:output) do
-        { "cookbook_name" => "cookbook_name",
-          "name" => "cookbook_name-0.0.0",
-          "frozen?" => false,
-          "version" => "0.0.0",
-          "metadata" => {
-            "name" => nil,
-            "description" => "",
-            "eager_load_libraries" => true,
-            "long_description" => "",
-            "maintainer" => "",
-            "maintainer_email" => "",
-            "license" => "All rights reserved",
-            "platforms" => {},
-            "dependencies" => {},
-            "providing" => {},
-            "recipes" => {},
-            "version" => "0.0.0",
-            "source_url" => "",
-            "issues_url" => "",
-            "privacy" => false,
-            "chef_versions" => [],
-            "ohai_versions" => [],
-            "gems" => [],
-          },
-          "recipes" =>
-          [{ "name" => "recipes/default.rb",
-             "path" => "recipes/default.rb",
-             "checksum" => "1234",
-             "url" => "http://example.org/files/default.rb" }],
-        }
-      end
-
-      it "should show the specific part of a cookbook" do
-        expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
-        expect(knife).to receive(:output).with(output)
-        knife.run
-      end
-    end
-
-    describe "with 3 arguments: name, version, and segment" do
-      before(:each) do
-        knife.name_args = [ "cookbook_name", "0.1.0", "recipes" ]
-      end
-
-      it "should print the json of the part" do
-        expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
-        expect(knife).to receive(:output).with(cb.files_for("recipes"))
-        knife.run
-      end
-    end
-
-    describe "with 4 arguments: name, version, segment and filename" do
-      before(:each) do
-        knife.name_args = [ "cookbook_name", "0.1.0", "recipes", "default.rb" ]
-      end
-
-      it "should print the raw result of the request (likely a file!)" do
-        expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
-        expect(rest).to receive(:streaming_request).with("http://example.org/files/default.rb").and_return(StringIO.new(content))
-        expect(knife).to receive(:pretty_print).with(content)
-        knife.run
-      end
-    end
-
-    describe "with 4 arguments: name, version, segment and filename -- with specificity" do
-      before(:each) do
-        knife.name_args = [ "cookbook_name", "0.1.0", "files", "afile.rb" ]
-        cb.manifest = {
-          "all_files" => [
-            {
-              name: "files/afile.rb",
-              path: "files/host-examplehost.example.org/afile.rb",
-              checksum: "1111",
-              specificity: "host-examplehost.example.org",
-              url: "http://example.org/files/1111",
-            },
-            {
-              name: "files/afile.rb",
-              path: "files/ubuntu-9.10/afile.rb",
-              checksum: "2222",
-              specificity: "ubuntu-9.10",
-              url: "http://example.org/files/2222",
-            },
-            {
-              name: "files/afile.rb",
-              path: "files/ubuntu/afile.rb",
-              checksum: "3333",
-              specificity: "ubuntu",
-              url: "http://example.org/files/3333",
-            },
-            {
-              name: "files/afile.rb",
-              path: "files/default/afile.rb",
-              checksum: "4444",
-              specificity: "default",
-              url: "http://example.org/files/4444",
-            },
-          ],
-        }
-
-      end
-
-      describe "with --fqdn" do
-        it "should pass the fqdn" do
-          knife.config[:platform] = "example_platform"
-          knife.config[:platform_version] = "1.0"
-          knife.config[:fqdn] = "examplehost.example.org"
-          expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
-          expect(rest).to receive(:streaming_request).with("http://example.org/files/1111").and_return(StringIO.new(content))
-          expect(knife).to receive(:pretty_print).with(content)
-          knife.run
-        end
-      end
-
-      describe "and --platform" do
-        it "should pass the platform" do
-          knife.config[:platform] = "ubuntu"
-          knife.config[:platform_version] = "1.0"
-          knife.config[:fqdn] = "differenthost.example.org"
-          expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
-          expect(rest).to receive(:streaming_request).with("http://example.org/files/3333").and_return(StringIO.new(content))
-          expect(knife).to receive(:pretty_print).with(content)
-          knife.run
-        end
-      end
-
-      describe "and --platform-version" do
-        it "should pass the platform" do
-          knife.config[:platform] = "ubuntu"
-          knife.config[:platform_version] = "9.10"
-          knife.config[:fqdn] = "differenthost.example.org"
-          expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
-          expect(rest).to receive(:streaming_request).with("http://example.org/files/2222").and_return(StringIO.new(content))
-          expect(knife).to receive(:pretty_print).with(content)
-          knife.run
-        end
-      end
-
-      describe "with none of the arguments, it should use the default" do
-        it "should pass them all" do
-          expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
-          expect(rest).to receive(:streaming_request).with("http://example.org/files/4444").and_return(StringIO.new(content))
-          expect(knife).to receive(:pretty_print).with(content)
-          knife.run
-        end
-      end
-
-    end
-  end
-end