chef-cli 1.0.13 → 1.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b5f6126a4c90780ea0e12bfb21478a40bce4d2432735b5ce2e36c6114414d06
-  data.tar.gz: beed8e750ba8df274e82be2aa11238a07d55968d1686b7c1f0393c303639dc5f
+  metadata.gz: 86cf14e43550aba70dc825275b3a3a6b86513da7d550a0bc610175a769d53d56
+  data.tar.gz: 3fc61ee5fcd4aaa816d370840383e078a5597d8d7cb71fdcf57390758ba380d1
 SHA512:
-  metadata.gz: 82d425973ce0b4e17c55a2f536773a5c9ad40ba50bdcd2b537b64d04462d4b9d970d27d642574f86529839549235007778b8c77608dfb19352b1fdef79c11e0d
-  data.tar.gz: 041f50bcdc2cbaab8efdc1f51b53d279d6cf1b11a72deac5124885ad1e8acf52fb4ab052ff9dade90b60d2dcae7e88f7371bec74184504ff23655028bc0da13c
+  metadata.gz: 87b2f14824b5c4e2f75a2e570434d5b52db36e8bd49b074857fec624240cf099c16cb8ea57ce8bffc81aca9843e3fe2647662d99d52438964008fc4e05b0b6b4
+  data.tar.gz: 7022751ac3061e3823180c51b2e3288970e0666d6a11dbf9c0d28e5b472860637fe44e7f3cb67d0453146c280fcfb369d0b87be7a0c48bf8fb57014c9c54c76b

data/lib/chef-cli/builtin_commands.rb

@@ -58,8 +58,6 @@ ChefCLI.commands do |c|
   c.builtin "describe-cookbook", :DescribeCookbook, require_path: "chef-cli/command/describe_cookbook",
                                                     desc: "Prints cookbook checksum information used for cookbook identifier"
 
-  c.builtin "verify", :Verify, desc: "Test the embedded #{ChefCLI::Dist::PRODUCT} applications", hidden: true
-
   # deprecated command that throws a failure warning if used. This was removed 4.2019
   c.builtin "provision", :Provision, desc: "Provision VMs and clusters via cookbook", hidden: true
 end

data/lib/chef-cli/exceptions.rb

@@ -44,12 +44,6 @@ module ChefCLI
   class InvalidPolicyfileAttribute < StandardError
   end
 
-  class MissingComponentError < RuntimeError
-    def initialize(component_name, reason)
-      super("Component #{component_name} is missing.\nReason: #{reason}")
-    end
-  end
-
   class OmnibusInstallNotFound < RuntimeError
     require_relative "dist"
 

data/lib/chef-cli/version.rb

@@ -16,5 +16,5 @@
 #
 
 module ChefCLI
-  VERSION = "1.0.13".freeze
+  VERSION = "1.0.14".freeze
 end

data/spec/unit/cli_spec.rb

@@ -48,7 +48,6 @@ describe ChefCLI::CLI do
 
 
       Available Commands:
-          verify   Test the embedded ChefCLI applications
           gem      Runs the `gem` command in context of the embedded ruby
           example  Example subcommand for testing
     E
@@ -94,8 +93,6 @@ describe ChefCLI::CLI do
   end
 
   before do
-    commands_map.builtin "verify", :Verify, desc: "Test the embedded ChefCLI applications"
-
     commands_map.builtin "gem", :GemForwarder, require_path: "chef-cli/command/gem",
                                                desc: "Runs the `gem` command in context of the embedded ruby"
 

data/spec/unit/command/base_spec.rb

@@ -16,7 +16,6 @@
 #
 
 require "spec_helper"
-require "chef-cli/command/verify"
 
 describe ChefCLI::Command::Base do
   class TestCommand < ChefCLI::Command::Base

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-cli
 version: !ruby/object:Gem::Version
-  version: 1.0.13
+  version: 1.0.14
 platform: ruby
 authors:
 - Chef Software, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-28 00:00:00.000000000 Z
+date: 2019-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-cli
@@ -256,12 +256,10 @@ files:
 - lib/chef-cli/command/show_policy.rb
 - lib/chef-cli/command/undelete.rb
 - lib/chef-cli/command/update.rb
-- lib/chef-cli/command/verify.rb
 - lib/chef-cli/commands_map.rb
 - lib/chef-cli/completions/bash.sh.erb
 - lib/chef-cli/completions/chef.fish.erb
 - lib/chef-cli/completions/zsh.zsh.erb
-- lib/chef-cli/component_test.rb
 - lib/chef-cli/configurable.rb
 - lib/chef-cli/cookbook_metadata.rb
 - lib/chef-cli/cookbook_omnifetch.rb
@@ -429,9 +427,7 @@ files:
 - spec/unit/command/show_policy_spec.rb
 - spec/unit/command/undelete_spec.rb
 - spec/unit/command/update_spec.rb
-- spec/unit/command/verify_spec.rb
 - spec/unit/commands_map_spec.rb
-- spec/unit/component_test_spec.rb
 - spec/unit/configurable_spec.rb
 - spec/unit/cookbook_metadata_spec.rb
 - spec/unit/cookbook_profiler/git_spec.rb
@@ -645,9 +641,7 @@ test_files:
 - spec/unit/command/show_policy_spec.rb
 - spec/unit/command/undelete_spec.rb
 - spec/unit/command/update_spec.rb
-- spec/unit/command/verify_spec.rb
 - spec/unit/commands_map_spec.rb
-- spec/unit/component_test_spec.rb
 - spec/unit/configurable_spec.rb
 - spec/unit/cookbook_metadata_spec.rb
 - spec/unit/cookbook_profiler/git_spec.rb

data/lib/chef-cli/command/verify.rb

@@ -1,547 +0,0 @@
-#
-# Copyright:: Copyright (c) 2014-2019 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_relative "base"
-require_relative "../exceptions"
-require_relative "../component_test"
-require_relative "../dist"
-
-module ChefCLI
-  module Command
-    class Verify < ChefCLI::Command::Base
-      # TODO 2019-07-05 mp - this gets a little odd, because
-      # this the commands that we verify here do not ship with
-      # the chef-cli component - they're only in Workstation and DK.
-      # This should continue to work in an installed Workstation package,
-      # but we will probably want to find some way of letting clients (Workstation)
-      # override this command so that it can report on all
-      # of the components it installs.
-      include ChefCLI::Helpers
-
-      banner "Usage: #{ChefCLI::Dist::EXEC} verify [component, ...] [options]"
-
-      option :omnibus_dir,
-        long: "--omnibus-dir OMNIBUS_DIR",
-        description: "Alternate path to omnibus install (used for testing)"
-
-      option :unit,
-        long: "--unit",
-        description: "Run bundled app unit tests (only smoke tests run by default)"
-
-      option :integration,
-        long: "--integration",
-        description: "Run integration tests. Possibly dangerous, for development systems only"
-
-      option :verbose,
-        long: "--verbose",
-        description: "Display all test output, not just failing tests"
-
-      class << self
-        def add_component(name, _delete_me = nil)
-          component = ComponentTest.new(name)
-          yield component if block_given? # delete this conditional
-          component_map[name] = component
-        end
-
-        def component(name)
-          component_map[name]
-        end
-
-        def components
-          component_map.values
-        end
-
-        def component_map
-          @component_map ||= {}
-        end
-      end
-
-      def components
-        self.class.components
-      end
-
-      bundle_install_mutex = Mutex.new
-
-      #
-      # Components included in Chef Development kit:
-      # :base_dir => Relative path of the component w.r.t. omnibus_apps_dir
-      # :gem_base_dir => Takes a gem name instead and uses first gem found
-      # :test_cmd => Test command to be launched for the component
-      #
-      add_component "berkshelf" do |c|
-        c.gem_base_dir = "berkshelf"
-        # For berks the real command to run is "#{embedded_bin("bundle")} exec thor spec:ci"
-        # We can't run it right now since graphviz specs are included in the
-        # test suite by default. We will be able to switch to that command when/if
-        # Graphviz is added to omnibus.
-        c.unit_test do
-          bundle_install_mutex.synchronize { sh("#{embedded_bin("bundle")} install") }
-          sh("#{embedded_bin("bundle")} exec #{embedded_bin("rspec")} --color --format progress spec/unit --tag ~graphviz")
-        end
-
-        # See older versions of this file in git to retrieve
-        # our cucumber test command for berkshelf.
-        # We had to remove them because we no longer bundle These tests cannot be run unless we bundle cucumber
-        # c.integration_test do
-        #   bundle_install_mutex.synchronize { sh("#{embedded_bin("bundle")} install") }
-        #   sh("#{embedded_bin("bundle")} exec #{embedded_bin("cucumber")} --color --format progress --tags ~@no_run --tags ~@spawn --tags ~@graphviz --strict")
-        # end
-
-        c.smoke_test do
-          tmpdir do |cwd|
-            FileUtils.touch(File.join(cwd, "Berksfile"))
-            sh("#{bin("berks")} install", cwd: cwd)
-          end
-        end
-      end
-
-      add_component "test-kitchen" do |c|
-        c.gem_base_dir = "test-kitchen"
-        c.unit_test do
-          bundle_install_mutex.synchronize { sh("#{embedded_bin("bundle")} install") }
-          sh("#{embedded_bin("bundle")} exec rake unit")
-        end
-        c.integration_test do
-          bundle_install_mutex.synchronize { sh("#{embedded_bin("bundle")} install") }
-          sh("#{embedded_bin("bundle")} exec rake features")
-        end
-
-        # NOTE: By default, kitchen tries to be helpful and install a driver
-        # gem for you. This causes a race condition when running the tests
-        # concurrently, because rubygems breaks when there are partially
-        # installed gems in the gem repository. Instructing kitchen to create a
-        # gemfile instead avoids the gem installation.
-        c.smoke_test { run_in_tmpdir("kitchen init --create-gemfile") }
-      end
-
-      add_component "tk-policyfile-provisioner" do |c|
-
-        c.gem_base_dir = "chef-cli"
-
-        c.smoke_test do
-          tmpdir do |cwd|
-            File.open(File.join(cwd, "kitchen.yml"), "w+") do |f|
-              f.print(<<~KITCHEN_YML)
-                ---
-                driver:
-                  name: dummy
-                  network:
-                    - ["forwarded_port", {guest: 80, host: 8080}]
-
-                provisioner:
-                  name: policyfile_zero
-                  require_chef_omnibus: 12.3.0
-
-                platforms:
-                  - name: ubuntu-14.04
-
-                suites:
-                  - name: default
-                    run_list:
-                      - recipe[aar::default]
-                    attributes:
-
-              KITCHEN_YML
-            end
-
-            sh("kitchen list", cwd: cwd)
-
-          end
-        end
-
-      end
-
-      add_component "chef-client" do |c|
-        c.gem_base_dir = "chef"
-        c.unit_test do
-          bundle_install_mutex.synchronize { sh("#{embedded_bin("bundle")} install") }
-          sh("#{embedded_bin("bundle")} exec #{embedded_bin("rspec")} -fp -t '~volatile_from_verify' spec/unit")
-        end
-        c.integration_test do
-          bundle_install_mutex.synchronize { sh("#{embedded_bin("bundle")} install") }
-          sh("#{embedded_bin("bundle")} exec #{embedded_bin("rspec")} -fp spec/integration spec/functional")
-        end
-
-        c.smoke_test do
-          tmpdir do |cwd|
-            FileUtils.touch(File.join(cwd, "apply.rb"))
-            sh("#{bin("chef-apply")} apply.rb --chef-license 'accept-no-persist'", cwd: cwd)
-          end
-        end
-      end
-
-      add_component "chef-cli" do |c|
-        c.gem_base_dir = "chef-cli"
-        c.unit_test do
-          bundle_install_mutex.synchronize { sh("#{embedded_bin("bundle")} install") }
-          sh("#{embedded_bin("bundle")} exec #{embedded_bin("rspec")}")
-        end
-        c.smoke_test do
-          run_in_tmpdir("#{bin("chef")} generate cookbook example")
-        end
-      end
-
-      add_component "chef-apply" do |c|
-        c.gem_base_dir = "chef-apply"
-      #   c.unit_test do
-      #     bundle_install_mutex.synchronize { sh("#{embedded_bin("bundle")} install") }
-      #     sh("#{embedded_bin("bundle")} exec rspec")
-      #   end
-        c.smoke_test { sh("#{bin("chef-run")} -v", env: { "CHEF_TELEMETRY_OPT_OUT" => "true" }) }
-      end
-
-      add_component "chefspec" do |c|
-        c.gem_base_dir = "chefspec"
-        c.unit_test do
-          bundle_install_mutex.synchronize { sh("#{embedded_bin("bundle")} install") }
-          sh("#{embedded_bin("bundle")} exec #{embedded_bin("rake")} unit")
-        end
-        c.smoke_test do
-          tmpdir do |cwd|
-            FileUtils.mkdir(File.join(cwd, "spec"))
-            with_file(File.join(cwd, "spec", "spec_helper.rb")) do |f|
-              f.write <<~EOF
-                require 'chefspec'
-                require 'chefspec/berkshelf'
-                require 'chefspec/cacher'
-
-                RSpec.configure do |config|
-                    config.expect_with(:rspec) { |c| c.syntax = :expect }
-                end
-              EOF
-            end
-            FileUtils.touch(File.join(cwd, "Berksfile"))
-            with_file(File.join(cwd, "spec", "foo_spec.rb")) do |f|
-              f.write <<~EOF
-                require 'spec_helper'
-              EOF
-            end
-            sh(embedded_bin("rspec"), cwd: cwd)
-          end
-        end
-      end
-
-      add_component "generated-cookbooks-pass-chefspec" do |c|
-
-        c.gem_base_dir = "chef-cli"
-        c.smoke_test do
-          tmpdir do |cwd|
-            sh("#{bin("chef")} generate cookbook example", cwd: cwd)
-            cb_cwd = File.join(cwd, "example")
-            sh(embedded_bin("rspec"), cwd: cb_cwd)
-          end
-        end
-      end
-
-      add_component "fauxhai" do |c|
-        c.gem_base_dir = "fauxhai"
-        c.smoke_test { sh("#{embedded_bin("gem")} list fauxhai") }
-      end
-
-      add_component "kitchen-vagrant" do |c|
-        c.gem_base_dir = "kitchen-vagrant"
-        # The build is not passing in travis, so no tests
-        c.smoke_test { sh("#{embedded_bin("gem")} list kitchen-vagrant") }
-      end
-
-      add_component "package installation" do |c|
-
-        c.gem_base_dir = "chef-cli"
-
-        c.smoke_test do
-
-          if File.directory?(usr_bin_prefix)
-            sh!("#{usr_bin_path("berks")} -v")
-            sh!("#{usr_bin_path("chef")} -v")
-            sh!("#{usr_bin_path("chef-client")} -v")
-            sh!("#{usr_bin_path("chef-solo")} -v")
-            sh!("#{usr_bin_path("delivery")} -V") unless Chef::Platform.windows?
-
-            # In `knife`, `knife -v` follows a different code path that skips
-            # command/plugin loading; `knife -h` loads commands and plugins, but
-            # it exits with code 1, which is the same as a load error. Running
-            # `knife exec` forces command loading to happen and this command
-            # exits 0, which runs most of the code.
-            #
-            # See also: https://github.com/chef/chef-cli/issues/227
-            sh!("#{usr_bin_path("knife")} exec -E true")
-
-            tmpdir do |dir|
-              # Kitchen tries to create a .kitchen dir even when just running
-              # `kitchen -v`:
-              sh!("#{usr_bin_path("kitchen")} -v", cwd: dir)
-            end
-
-            sh!("#{usr_bin_path("ohai")} -v")
-            sh!("#{usr_bin_path("foodcritic")} -V")
-            sh!("#{usr_bin_path("inspec")} version")
-          end
-
-          # Test blocks are expected to return a Mixlib::ShellOut compatible
-          # object:
-          ComponentTest::NullTestResult.new
-        end
-      end
-
-      add_component "openssl" do |c|
-        # https://github.com/chef/chef-cli/issues/420
-        c.gem_base_dir = "chef"
-
-        test = <<-EOF.gsub(/^\s+/, "")
-        require "net/http" unless defined?(Net::HTTP)
-
-        uris = %w{https://www.google.com https://chef.io/ https://ec2.amazonaws.com}
-        uris.each do |uri|
-          uri = URI(uri)
-          puts "Fetching \#{uri} for SSL check"
-          Net::HTTP.get uri
-        end
-        EOF
-
-        c.unit_test do
-          tmpdir do |cwd|
-            with_file(File.join(cwd, "openssl.rb")) do |f|
-              f.write test
-            end
-            sh!("#{Gem.ruby} openssl.rb", cwd: cwd)
-          end
-        end
-      end
-
-      add_component "inspec" do |c|
-        c.gem_base_dir = "inspec"
-
-        # Commenting out the unit and integration tests for now until we figure
-        # out the bundler error
-        # c.unit_test { sh("#{embedded_bin("bundle")} exec rake test:isolated") }
-        # This runs Test Kitchen (using kitchen-inspec) with some inspec tests
-        # c.integration_test { sh("#{embedded_bin("bundle")} exec rake test:vm") }
-
-        # It would be nice to use a chef generator to create these specs, but
-        # we dont have that yet.  So we do it manually.
-        c.smoke_test do
-          tmpdir do |cwd|
-            File.open(File.join(cwd, "some_spec.rb"), "w+") do |f|
-              f.print <<-INSPEC_TEST
-                rule '01' do
-                  impact 0.7
-                  title 'Some Test'
-                  desc 'Make sure inspec is installed and loading correct'
-                  describe 1 do
-                    it { should eq(1) }
-                  end
-                end
-              INSPEC_TEST
-            end
-            # TODO when we appbundle inspec, no longer `chef exec`
-            sh("#{bin("chef")} exec #{embedded_bin("inspec")} exec .", cwd: cwd)
-          end
-        end
-      end
-
-      add_component "delivery-cli" do |c|
-        # We'll want to come back and revisit getting unit tests added -
-        # currently running the tests depends on cargo , which is not included
-        # in our package.
-        c.base_dir = "bin"
-        c.smoke_test do
-          tmpdir do |cwd|
-            sh!("delivery setup --user=shipit --server=delivery.shipit.io --ent=chef --org=squirrels", cwd: cwd)
-          end
-        end
-      end
-
-      if Chef::Platform.windows?
-        add_component "git" do |c|
-          c.base_dir = "embedded/bin"
-          c.smoke_test do
-            tmpdir do |cwd|
-              sh!("#{embedded_bin("git")} config -l")
-              sh!("#{embedded_bin("git")} clone https://github.com/chef/license-acceptance", cwd: cwd)
-            end
-          end
-        end
-      else
-        add_component "git" do |c|
-          c.base_dir = "gitbin"
-          c.smoke_test do
-            tmpdir do |cwd|
-              sh!("#{File.join(omnibus_root, "gitbin", "git")} config -l")
-              sh!("#{File.join(omnibus_root, "gitbin", "git")} clone https://github.com/chef/license-acceptance", cwd: cwd)
-
-              # If /usr/bin/git is a symlink, fail the test.
-              # Note that this test cannot go last because it does not return a
-              # Mixlib::Shellout object in the windows case, which will break the tests.
-              failure_str = "#{nix_platform_native_bin_dir}/git contains a symlink which might mean we accidentally overwrote system git via chefcli."
-              result = sh("readlink #{nix_platform_native_bin_dir}/git")
-              # if a symlink was found, test to see if it is in a chefcli install
-              if result.status.exitstatus == 0
-                raise failure_str if result.stdout =~ /chefcli/
-              end
-
-              # <chef_dk>/bin/ should not contain a git binary.
-              failure_str = "`<chef_dk>/bin/git --help` should fail as git should be installed in gitbin"
-              fail_if_exit_zero("#{bin("git")} --help", failure_str)
-            end
-          end
-        end
-      end
-
-      add_component "opscode-pushy-client" do |c|
-        c.gem_base_dir = "opscode-pushy-client"
-        # TODO the unit tests are currently failing in master
-        # c.unit_test do
-        #   bundle_install_mutex.synchronize { sh("#{embedded_bin("bundle")} install") }
-        #   sh("#{embedded_bin("bundle")} exec rake spec")
-        # end
-
-        c.smoke_test do
-          tmpdir do |cwd|
-            sh("#{bin("pushy-client")} -v", cwd: cwd)
-          end
-        end
-      end
-
-      # We try and use some chef-sugar code to make sure it loads correctly
-      add_component "chef-sugar" do |c|
-        c.gem_base_dir = "chef-sugar"
-        c.smoke_test do
-          tmpdir do |cwd|
-            with_file(File.join(cwd, "foo.rb")) do |f|
-              f.write <<~EOF
-                require 'chef/sugar'
-                log 'something' do
-                  not_if  { _64_bit? }
-                end
-              EOF
-            end
-            sh("#{bin("chef-apply")} foo.rb", cwd: cwd)
-          end
-        end
-      end
-
-      attr_reader :verification_threads
-      attr_reader :verification_results
-      attr_reader :verification_status
-
-      def initialize
-        super
-        @verification_threads = [ ]
-        @verification_results = [ ]
-        @verification_status = 0
-      end
-
-      def run(params = [ ])
-        err("[WARN] This is an internal command used by the ChefCLI development team. If you are a ChefCLI user, please do not run it.")
-        @components_filter = parse_options(params)
-
-        validate_components!
-        invoke_tests
-        wait_for_tests
-        report_results
-
-        verification_status
-      end
-
-      def omnibus_root
-        config[:omnibus_dir] || super
-      end
-
-      def validate_components!
-        components.each do |component|
-          component.omnibus_root = omnibus_root
-          component.assert_present!
-        end
-      end
-
-      def components_to_test
-        if @components_filter.empty?
-          components
-        else
-          components.select do |component|
-            @components_filter.include?(component.name.to_s)
-          end
-        end
-      end
-
-      def invoke_tests
-        components_to_test.each do |component|
-          # Run the component specs in parallel
-          verification_threads << Thread.new do
-
-            results = []
-
-            results << component.run_smoke_test
-
-            if config[:unit]
-              results << component.run_unit_test
-            end
-
-            if config[:integration]
-              results << component.run_integration_test
-            end
-
-            if results.any? { |r| r.exitstatus != 0 }
-              component_status = 1
-              @verification_status = 1
-            else
-              component_status = 0
-            end
-
-            {
-              component: component,
-              results: results,
-              component_status: component_status,
-            }
-          end
-
-          msg("Running verification for component '#{component.name}'")
-        end
-      end
-
-      def wait_for_tests
-        until verification_threads.empty?
-          verification_threads.each do |t|
-            if t.join(1)
-              verification_threads.delete t
-              verification_results << t.value
-              t.value[:results].each do |result|
-                if config[:verbose] || t.value[:component_status] != 0
-                  msg("")
-                  msg(result.stdout)
-                  msg(result.stderr) if result.stderr
-                end
-              end
-            else
-              $stdout.write "."
-            end
-          end
-        end
-      end
-
-      def report_results
-        msg("")
-        msg("---------------------------------------------")
-        verification_results.each do |result|
-          message = result[:component_status] == 0 ? "succeeded" : "failed"
-          msg("Verification of component '#{result[:component].name}' #{message}.")
-        end
-      end
-
-    end
-  end
-end

data/lib/chef-cli/component_test.rb

@@ -1,227 +0,0 @@
-#
-# Copyright:: Copyright (c) 2014-2019 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_relative "exceptions"
-require_relative "helpers"
-
-# https://github.com/bundler/bundler/issues/4368
-# As of rubygems 2.6.2, Rubygems will call Bundler::SpecSet#size, which does
-# not exist as of Bundler 1.11.2.
-#
-# `#size` and `#length` should be synonyms in idiomatic ruby so we alias to
-# make bundler and rubygems play nicely.
-if Object.const_defined?(:Bundler) &&
-    Bundler.const_defined?(:SpecSet) &&
-    Bundler::SpecSet.instance_methods.include?(:length) &&
-    !Bundler::SpecSet.instance_methods.include?(:size)
-
-  module Bundler
-    class SpecSet
-
-      alias_method :size, :length
-
-    end
-  end
-
-end
-
-module ChefCLI
-  class ComponentTest
-
-    class NullTestResult
-      def exitstatus
-        0
-      end
-
-      def stdout
-        ""
-      end
-
-      def stderr
-        ""
-      end
-    end
-
-    DEFAULT_TEST = lambda { |context| NullTestResult.new }
-
-    include Helpers
-
-    attr_accessor :base_dir
-
-    attr_writer :omnibus_root
-
-    attr_reader :name
-
-    def initialize(name)
-      @name = name
-      @unit_test = DEFAULT_TEST
-      @integration_test = DEFAULT_TEST
-      @smoke_test = DEFAULT_TEST
-      @base_dir = nil
-      @gem_name_for_base_dir = nil
-    end
-
-    def unit_test(&test_block)
-      @unit_test = test_block
-    end
-
-    def run_unit_test
-      instance_eval(&@unit_test)
-    end
-
-    def integration_test(&test_block)
-      @integration_test = test_block
-    end
-
-    def run_integration_test
-      instance_eval(&@integration_test)
-    end
-
-    def smoke_test(&test_block)
-      @smoke_test = test_block
-    end
-
-    def run_smoke_test
-      instance_eval(&@smoke_test)
-    end
-
-    def bin(binary)
-      File.join(omnibus_bin_dir, binary)
-    end
-
-    def embedded_bin(binary)
-      File.join(omnibus_embedded_bin_dir, binary)
-    end
-
-    def sh(command, options = {})
-      combined_opts = default_command_options.merge(options)
-
-      # Env is a hash, so it needs to be merged separately
-      if options.key?(:env)
-        combined_opts[:env] = default_command_options[:env].merge(options[:env])
-      end
-      system_command(command, combined_opts)
-    end
-
-    # Just like #sh but raises an error if the the command returns an
-    # unexpected exit code.
-    #
-    # Most verification steps just run a single command, then
-    # ChefCLI::Command::Verify#invoke_tests handles the results by inspecting
-    # the return value of the test block. For tests that run a lot of commands,
-    # this is inconvenient so you can use #sh! instead.
-    def sh!(*args)
-      sh(*args).tap(&:error!)
-    end
-
-    # Run a command, if the command returns zero, raise an error,
-    # otherwise, if it returns non-zero or doesn't exist,
-    # return a passing command so that the test parser doesn't
-    # crash.
-    def fail_if_exit_zero(cmd_string, failure_string = "")
-      result = sh(cmd_string)
-      if result.status.exitstatus == 0
-        raise failure_string
-      else
-        sh("true")
-      end
-    rescue Errno::ENOENT
-      sh("true")
-    end
-
-    def nix_platform_native_bin_dir
-      if /darwin/ =~ RUBY_PLATFORM
-        "/usr/local/bin"
-      else
-        "/usr/bin"
-      end
-    end
-
-    def run_in_tmpdir(command, options = {})
-      tmpdir do |dir|
-        options[:cwd] = dir
-        sh(command, options)
-      end
-    end
-
-    def tmpdir
-      Dir.mktmpdir do |tmpdir|
-        yield tmpdir
-      end
-    end
-
-    def assert_present!
-      unless File.exist?( component_path )
-        raise MissingComponentError.new(name, "Could not find #{component_path}")
-      end
-    rescue Gem::LoadError => e
-      raise MissingComponentError.new(name, e)
-    end
-
-    def default_command_options
-      {
-        cwd: component_path,
-        env: {
-          # Add the embedded/bin to the PATH so that bundle executable can
-          # be found while running the tests.
-          path_variable_key => omnibus_path,
-          "CHEF_LICENSE" => "accept-no-persist",
-        },
-        timeout: 3600,
-      }
-    end
-
-    def component_path
-      if base_dir
-        File.join(omnibus_root, base_dir)
-      elsif gem_base_dir
-        gem_base_dir
-      else
-        raise "`base_dir` or `gem_base_dir` must be defined for component `#{name}`"
-      end
-    end
-
-    def gem_base_dir
-      return nil if @gem_name_for_base_dir.nil?
-
-      # There is no way to say "give me the latest prerelease OR normal version of this gem.
-      # So we first ask if there is a normal version, and if there is not, we ask if there
-      # is a prerelease version.  ">= 0.a" is how we ask for a prerelease version, because a
-      # prerelease version is defined as "any version with a letter in it."
-      gem = Gem::Specification.find_by_name(@gem_name_for_base_dir)
-      gem ||= Gem::Specification.find_by_name(@gem_name_for_base_dir, ">= 0.a")
-      gem.gem_dir
-    end
-
-    def gem_base_dir=(gem_name)
-      @gem_name_for_base_dir = gem_name
-    end
-
-    def omnibus_root
-      @omnibus_root || raise("`omnibus_root` must be set before running tests")
-    end
-
-    def omnibus_path
-      [omnibus_bin_dir, omnibus_embedded_bin_dir, ENV["PATH"]].join(File::PATH_SEPARATOR)
-    end
-
-    def path_variable_key
-      ENV.keys.grep(/\Apath\Z/i).first
-    end
-
-  end
-end

data/spec/unit/command/verify_spec.rb

@@ -1,340 +0,0 @@
-#
-# Copyright:: Copyright (c) 2014-2018 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-cli/command/verify"
-
-module Gem
-
-  # We stub Gem.ruby because `verify` uses it to locate the omnibus directory,
-  # but we also use it in some of the "test commands" in these tests.
-  class << self
-    alias :real_ruby :ruby
-  end
-end
-
-describe ChefCLI::Command::Verify do
-
-  let(:command_instance) { ChefCLI::Command::Verify.new }
-
-  let(:command_options) { [] }
-
-  let(:components) { {} }
-
-  let(:default_components) do
-    [
-      "berkshelf",
-      "test-kitchen",
-      "tk-policyfile-provisioner",
-      "chef-client",
-      "chef-cli",
-      "chef-apply",
-      "chefspec",
-      "generated-cookbooks-pass-chefspec",
-      "fauxhai",
-      "kitchen-vagrant",
-      "package installation",
-      "openssl",
-      "inspec",
-      "chef-sugar",
-      "opscode-pushy-client",
-      "git",
-      "delivery-cli",
-    ]
-  end
-
-  def run_command(expected_exit_code)
-    expect(command_instance.run(command_options)).to eq(expected_exit_code)
-  end
-
-  it "defines berks, tk, chef and chef-cli components by default" do
-    expected_components = default_components
-    expect(command_instance.components).not_to be_empty
-    expect(command_instance.components.map(&:name)).to match_array(expected_components)
-  end
-
-  it "has a usage banner" do
-    expect(command_instance.banner).to eq("Usage: chef verify [component, ...] [options]")
-  end
-
-  describe "when locating omnibus directory from the ruby path" do
-    it "should find omnibus root directory from ruby path" do
-      allow(Gem).to receive(:ruby).and_return(File.join(fixtures_path, "eg_omnibus_dir/valid/embedded/bin/ruby"))
-      expect(command_instance.omnibus_root).to end_with("eg_omnibus_dir/valid")
-    end
-
-    it "should raise OmnibusInstallNotFound if directory is not looking like omnibus" do
-      allow(Gem).to receive(:ruby).and_return(File.join(fixtures_path, ".rbenv/versions/2.1.1/bin/ruby"))
-      expect { command_instance.omnibus_bin_dir }.to raise_error(ChefCLI::OmnibusInstallNotFound)
-    end
-
-    it "raises OmnibusInstallNotFound if omnibus directory doesn't exist" do
-      allow(Gem).to receive(:ruby).and_return(File.join(fixtures_path, "eg_omnibus_dir/invalid/embedded/bin/ruby"))
-      expect { command_instance.omnibus_bin_dir }.to raise_error(ChefCLI::OmnibusInstallNotFound)
-    end
-
-    context "and a component's gem is not installed" do
-      before do
-        component_map = ChefCLI::Command::Verify.component_map.dup
-        component_map["cucumber"] = ChefCLI::ComponentTest.new("cucumber")
-        component_map["cucumber"].gem_base_dir = "cucumber"
-        allow(ChefCLI::Command::Verify).to receive(:component_map).and_return(component_map)
-      end
-
-      it "raises MissingComponentError when a component doesn't exist" do
-        allow(Gem).to receive(:ruby).and_return(File.join(fixtures_path, "eg_omnibus_dir/missing_component/embedded/bin/ruby"))
-        expect { command_instance.validate_components! }.to raise_error(ChefCLI::MissingComponentError)
-      end
-    end
-  end
-
-  describe "when running verify command" do
-    let(:stdout_io) { StringIO.new }
-    let(:stderr_io) { StringIO.new }
-    let(:ruby_path) { File.join(fixtures_path, "eg_omnibus_dir/valid/embedded/bin/ruby") }
-
-    def run_unit_test
-      # Set rubyopt to empty to prevent bundler from infecting the ruby
-      # subcommands (and loading a bunch of extra gems).
-      lambda { |_self| sh("#{Gem.real_ruby} verify_me", env: { "RUBYOPT" => "" }) }
-    end
-
-    def run_integration_test
-      lambda { |_self| sh("#{Gem.real_ruby} integration_test", env: { "RUBYOPT" => "" }) }
-    end
-
-    let(:all_tests_ok) do
-      ChefCLI::ComponentTest.new("successful_comp").tap do |c|
-        c.base_dir = "embedded/apps/berkshelf"
-        c.unit_test(&run_unit_test)
-        c.integration_test(&run_integration_test)
-        c.smoke_test { sh("exit 0") }
-      end
-    end
-
-    let(:all_tests_ok_2) do
-      ChefCLI::ComponentTest.new("successful_comp_2").tap do |c|
-        c.base_dir = "embedded/apps/test-kitchen"
-        c.unit_test(&run_unit_test)
-        c.smoke_test { sh("exit 0") }
-      end
-    end
-
-    let(:failing_unit_test) do
-      ChefCLI::ComponentTest.new("failing_comp").tap do |c|
-        c.base_dir = "embedded/apps/chef"
-        c.unit_test(&run_unit_test)
-        c.smoke_test { sh("exit 0") }
-      end
-    end
-
-    let(:passing_smoke_test_only) do
-      component = failing_unit_test.dup
-      component.smoke_test { sh("exit 0") }
-      component
-    end
-
-    let(:failing_smoke_test_only) do
-      component = all_tests_ok.dup
-      component.smoke_test { sh("exit 1") }
-      component
-    end
-
-    let(:component_without_integration_tests) do
-      ChefCLI::ComponentTest.new("successful_comp").tap do |c|
-        c.base_dir = "embedded/apps/berkshelf"
-        c.unit_test { sh("./verify_me") }
-        c.smoke_test { sh("exit 0") }
-      end
-    end
-
-    def stdout
-      stdout_io.string
-    end
-
-    before do
-      allow(Gem).to receive(:ruby).and_return(ruby_path)
-      allow(command_instance).to receive(:stdout).and_return(stdout_io)
-      allow(command_instance).to receive(:stderr).and_return(stderr_io)
-      allow(command_instance).to receive(:components).and_return(components)
-    end
-
-    context "when running smoke tests only" do
-      describe "with single command with success" do
-        let(:components) do
-          [ passing_smoke_test_only ]
-        end
-
-        before do
-          run_command(0)
-        end
-
-        it "should report the success of the command" do
-          expect(stdout).to include("Verification of component 'failing_comp' succeeded.")
-        end
-
-      end
-
-      describe "with single command with failure" do
-        let(:components) do
-          [ failing_smoke_test_only ]
-        end
-
-        before do
-          run_command(1)
-        end
-
-        it "should report the failure of the command" do
-          expect(stdout).to include("Verification of component 'successful_comp' failed.")
-        end
-
-      end
-    end
-
-    context "when running unit tests" do
-
-      let(:command_options) { %w{--unit --verbose} }
-
-      let(:components) do
-        [ all_tests_ok ]
-      end
-
-      describe "with single command with success" do
-        before do
-          run_command(0)
-        end
-
-        it "should have embedded/bin on the PATH" do
-          expect(stdout).to include(File.join(fixtures_path, "eg_omnibus_dir/valid/embedded/bin"))
-        end
-
-        it "should report the success of the command" do
-          expect(stdout).to include("Verification of component 'successful_comp' succeeded.")
-        end
-
-        it "reports the component test output" do
-          expect(stdout).to include("you are good to go...")
-        end
-
-        context "and --verbose is not enabled" do
-
-          let(:command_options) { %w{--unit} }
-
-          it "omits the component test output" do
-            expect(stdout).to_not include("you are good to go...")
-          end
-        end
-
-        context "and --integration flag is given" do
-
-          let(:command_options) { %w{--integration --verbose} }
-
-          it "should run the integration command also" do
-            expect(stdout).to include("integration tests OK")
-          end
-
-          context "and no integration test command is specifed for the component" do
-
-            let(:components) do
-              [ component_without_integration_tests ]
-            end
-
-            it "skips the integration test and succeeds" do
-              expect(stdout).to include("Verification of component 'successful_comp' succeeded.")
-            end
-
-          end
-
-        end
-
-      end
-
-      describe "with single command with failure" do
-        let(:components) do
-          [ failing_unit_test ]
-        end
-
-        before do
-          run_command(1)
-        end
-
-        it "should report the failure of the command" do
-          expect(stdout).to include("Verification of component 'failing_comp' failed.")
-        end
-
-        it "reports the component test output" do
-          expect(stdout).to include("i'm not feeling good today...")
-        end
-      end
-
-      describe "with multiple commands with success" do
-        let(:components) do
-          [ all_tests_ok, all_tests_ok_2 ]
-        end
-
-        before do
-          run_command(0)
-        end
-
-        it "should report the success of the command" do
-          expect(stdout).to include("Verification of component 'successful_comp' succeeded.")
-          expect(stdout).to include("Verification of component 'successful_comp_2' succeeded.")
-        end
-
-        it "reports the component test outputs" do
-          expect(stdout).to include("you are good to go...")
-          expect(stdout).to include("my friend everything is good...")
-        end
-
-        context "and components are filtered by CLI args" do
-
-          let(:command_options) { [ "successful_comp_2" ] }
-
-          it "verifies only the desired component" do
-            expect(stdout).to_not include("Verification of component 'successful_comp_1' succeeded.")
-            expect(stdout).to include("Verification of component 'successful_comp_2' succeeded.")
-          end
-
-        end
-      end
-
-      describe "with multiple commands with failures" do
-        let(:components) do
-          [ all_tests_ok, all_tests_ok_2, failing_unit_test ]
-        end
-
-        before do
-          run_command(1)
-        end
-
-        it "should report the success and failure of the commands" do
-          expect(stdout).to include("Verification of component 'successful_comp' succeeded.")
-          expect(stdout).to include("Verification of component 'successful_comp_2' succeeded.")
-          expect(stdout).to include("Verification of component 'failing_comp' failed.")
-        end
-
-        it "reports the component test outputs" do
-          expect(stdout).to include("you are good to go...")
-          expect(stdout).to include("my friend everything is good...")
-          expect(stdout).to include("i'm not feeling good today...")
-        end
-      end
-
-    end
-  end
-
-end

data/spec/unit/component_test_spec.rb

@@ -1,128 +0,0 @@
-#
-# Copyright:: Copyright (c) 2014-2018 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-cli/component_test"
-require "pathname"
-
-describe ChefCLI::ComponentTest do
-
-  let(:component) do
-    ChefCLI::ComponentTest.new("berkshelf").tap do |c|
-      c.base_dir = "berkshelf"
-    end
-  end
-
-  it "defines the component" do
-    expect(component.name).to eq("berkshelf")
-  end
-
-  it "sets the component base directory" do
-    expect(component.base_dir).to eq("berkshelf")
-  end
-
-  it "defines a default unit test" do
-    expect(component.run_unit_test.exitstatus).to eq(0)
-    expect(component.run_unit_test.stdout).to eq("")
-    expect(component.run_unit_test.stderr).to eq("")
-  end
-
-  it "defines a default integration test" do
-    expect(component.run_integration_test.exitstatus).to eq(0)
-    expect(component.run_integration_test.stdout).to eq("")
-    expect(component.run_integration_test.stderr).to eq("")
-  end
-
-  it "defines a default smoke test" do
-    expect(component.run_smoke_test.exitstatus).to eq(0)
-    expect(component.run_smoke_test.stdout).to eq("")
-    expect(component.run_smoke_test.stderr).to eq("")
-  end
-
-  context "with basic tests defined" do
-
-    let(:result) { {} }
-
-    before do
-      # capture a reference to results hash so we can use it in tests.
-      result_hash = result
-      component.tap do |c|
-        c.unit_test { result_hash[:unit_test] = true }
-        c.integration_test { result_hash[:integration_test] = true }
-        c.smoke_test { result_hash[:smoke_test] = true }
-      end
-    end
-
-    it "defines a unit test block" do
-      component.run_unit_test
-      expect(result[:unit_test]).to be true
-    end
-
-    it "defines an integration test block" do
-      component.run_integration_test
-      expect(result[:integration_test]).to be true
-    end
-
-    it "defines a smoke test block" do
-      component.run_smoke_test
-      expect(result[:smoke_test]).to be true
-    end
-
-  end
-
-  context "with tests that shell out to commands" do
-
-    let(:omnibus_root) { File.join(fixtures_path, "eg_omnibus_dir/valid/") }
-
-    before do
-      component.tap do |c|
-        # Have to set omnibus dir so command can run with correct cwd
-        c.omnibus_root = omnibus_root
-
-        c.base_dir = "embedded/apps/berkshelf"
-
-        c.unit_test { sh("true") }
-
-        c.integration_test { sh("ruby -e 'puts Dir.pwd'", env: { "RUBYOPT" => "" }) }
-
-        c.smoke_test { run_in_tmpdir("ruby -e 'puts Dir.pwd'", env: { "RUBYOPT" => "" }) }
-      end
-    end
-
-    it "shells out and returns the shell out object" do
-      expect(component.run_unit_test.exitstatus).to eq(0)
-      expect(component.run_unit_test.stdout).to eq("")
-      expect(component.run_unit_test.stderr).to eq("")
-    end
-
-    it "runs the command in the app's root" do
-      result = component.run_integration_test
-      expected_path = Pathname.new(File.join(omnibus_root, "embedded/apps/berkshelf")).realpath
-      expect(Pathname.new(result.stdout.strip).realpath).to eq(expected_path)
-    end
-
-    it "runs commands in a temporary directory when specified" do
-      result = component.run_smoke_test
-
-      parent_of_cwd = Pathname.new(result.stdout.strip).parent.realpath
-      tempdir = Pathname.new(Dir.tmpdir).realpath
-      expect(parent_of_cwd).to eq(tempdir)
-    end
-
-  end
-
-end