chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/support/shared/integration/integration_helper.rb

@@ -0,0 +1,166 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Author:: Ho-Sheng Hsiao (<hosh@opscode.com>)
+# Copyright:: Copyright (c) 2012, 2013 Opscode, 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 'tmpdir'
+require 'fileutils'
+require 'chef/config'
+require 'chef_zero/rspec'
+require 'json'
+require 'support/shared/integration/knife_support'
+require 'spec_helper'
+
+module IntegrationSupport
+  include ChefZero::RSpec
+
+  def self.extended(base)
+    base.before :each do
+      # We mess with Chef::Config a lot.  Save and restore it.
+      @old_chef_config = Chef::Config.configuration
+      Chef::Config.configuration = Chef::Config.configuration.dup
+      Chef::Config.repo_mode = nil
+      Chef::Config.versioned_cookbooks = nil
+    end
+    base.after :each do
+      Chef::Config.configuration = @old_chef_config
+    end
+  end
+
+  def when_the_repository(description, *args, &block)
+    context "When the local repository #{description}", *args do
+      before :each do
+        raise "Can only create one directory per test" if @repository_dir
+        @repository_dir = Dir.mktmpdir('chef_repo')
+        @old_chef_repo_path = Chef::Config.chef_repo_path
+        @old_paths = {}
+        Chef::Config.chef_repo_path = @repository_dir
+        %w(client cookbook data_bag environment node role user).each do |object_name|
+          @old_paths[object_name] = Chef::Config["#{object_name}_path".to_sym]
+          Chef::Config["#{object_name}_path".to_sym] = nil
+        end
+      end
+
+      after :each do
+        if @repository_dir
+          begin
+            %w(client cookbook data_bag environment node role user).each do |object_name|
+              Chef::Config["#{object_name}_path".to_sym] = @old_paths[object_name]
+            end
+            Chef::Config.chef_repo_path = @old_chef_repo_path
+            FileUtils.remove_entry_secure(@repository_dir)
+          ensure
+            @old_chef_repo_path = nil
+            @old_paths = nil
+            @repository_dir = nil
+          end
+        end
+      end
+
+      def directory(relative_path, &block)
+        old_parent_path = @parent_path
+        @parent_path = path_to(relative_path)
+        FileUtils.mkdir_p(@parent_path)
+        instance_eval(&block) if block
+        @parent_path = old_parent_path
+      end
+
+      def file(relative_path, contents)
+        filename = path_to(relative_path)
+        dir = File.dirname(filename)
+        FileUtils.mkdir_p(dir) unless dir == '.'
+        File.open(filename, 'w') do |file|
+          raw = case contents
+                when Hash
+                  JSON.pretty_generate(contents)
+                when Array
+                  contents.join("\n")
+                else
+                  contents
+                end
+          file.write(raw)
+        end
+      end
+
+      def symlink(relative_path, relative_dest)
+        filename = path_to(relative_path)
+        dir = File.dirname(filename)
+        FileUtils.mkdir_p(dir) unless dir == '.'
+        dest_filename = path_to(relative_dest)
+        File.symlink(dest_filename, filename)
+      end
+
+      def path_to(relative_path)
+        File.expand_path(relative_path, (@parent_path || @repository_dir))
+      end
+
+      def self.path_to(relative_path)
+        File.expand_path(relative_path, (@parent_path || @repository_dir))
+      end
+
+      def self.directory(relative_path, &block)
+        before :each do
+          directory(relative_path, &block)
+        end
+      end
+
+      def self.file(relative_path, contents)
+        before :each do
+          file(relative_path, contents)
+        end
+      end
+
+      def self.symlink(relative_path, relative_dest)
+        before :each do
+          symlink(relative_path, relative_dest)
+        end
+      end
+
+      def self.cwd(relative_path)
+        before :each do
+          @old_cwd = Dir.pwd
+          Dir.chdir(path_to(relative_path))
+        end
+        after :each do
+          Dir.chdir(@old_cwd)
+        end
+      end
+
+      instance_eval(&block)
+    end
+  end
+
+  # Versioned cookbooks
+
+  def with_versioned_cookbooks(_metadata = {}, &block)
+    _m = { :versioned_cookbooks => true }.merge(_metadata)
+    context 'with versioned cookbooks', _m do
+      before(:each) { Chef::Config[:versioned_cookbooks] = true }
+      after(:each)  { Chef::Config[:versioned_cookbooks] = false }
+      instance_eval(&block)
+    end
+  end
+
+  def without_versioned_cookbooks(_metadata = {}, &block)
+    _m = { :versioned_cookbooks => false }.merge(_metadata)
+    context 'with versioned cookbooks', _m do
+      # Just make sure this goes back to default
+      before(:each) { Chef::Config[:versioned_cookbooks] = false }
+      instance_eval(&block)
+    end
+  end
+end

data/spec/support/shared/integration/knife_support.rb

@@ -0,0 +1,171 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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 'chef/config'
+require 'chef/knife'
+require 'chef/application/knife'
+require 'logger'
+require 'chef/log'
+
+module KnifeSupport
+  DEBUG = ENV['DEBUG']
+  def knife(*args, &block)
+    # Allow knife('role from file roles/blah.json') rather than requiring the
+    # arguments to be split like knife('role', 'from', 'file', 'roles/blah.json')
+    # If any argument will have actual spaces in it, the long form is required.
+    # (Since knife commands always start with the command name, and command
+    # names with spaces are always multiple args, this is safe.)
+    if args.length == 1
+      args = args[0].split(/\s+/)
+    end
+
+    # Make output stable
+    Chef::Config[:concurrency] = 1
+
+    # Work on machines where we can't access /var
+    checksums_cache_dir = Dir.mktmpdir('checksums') do |checksums_cache_dir|
+      old_cache_options = Chef::Config[:cache_options]
+      Chef::Config[:cache_options] = {
+        :path => checksums_cache_dir,
+        :skip_expires => true
+      }
+
+      # This is Chef::Knife.run without load_commands--we'll load stuff
+      # ourselves, thank you very much
+      stdout = StringIO.new
+      stderr = StringIO.new
+      old_loggers = Chef::Log.loggers
+      old_log_level = Chef::Log.level
+      begin
+        puts "knife: #{args.join(' ')}" if DEBUG
+        subcommand_class = Chef::Knife.subcommand_class_from(args)
+        subcommand_class.options = Chef::Application::Knife.options.merge(subcommand_class.options)
+        subcommand_class.load_deps
+        instance = subcommand_class.new(args)
+
+        # Capture stdout/stderr
+        instance.ui = Chef::Knife::UI.new(stdout, stderr, STDIN, {})
+
+        # Don't print stuff
+        Chef::Config[:verbosity] = ( DEBUG ? 2 : 0 )
+        instance.config[:config_file] = File.join(CHEF_SPEC_DATA, "null_config.rb")
+
+
+        # Configure chef with a (mostly) blank knife.rb
+        # We set a global and then mutate it in our stub knife.rb so we can be
+        # extra sure that we're not loading someone's real knife.rb and then
+        # running test scenarios against a real chef server. If things don't
+        # smell right, abort.
+
+        $__KNIFE_INTEGRATION_FAILSAFE_CHECK = "ole"
+        instance.configure_chef
+
+        unless $__KNIFE_INTEGRATION_FAILSAFE_CHECK == "ole ole"
+          raise Exception, "Potential misconfiguration of integration tests detected. Aborting test."
+        end
+
+        logger = Logger.new(stderr)
+        logger.formatter = proc { |severity, datetime, progname, msg| "#{severity}: #{msg}\n" }
+        Chef::Log.use_log_devices([logger])
+        Chef::Log.level = ( DEBUG ? :debug : :warn )
+        Chef::Log::Formatter.show_time = false
+
+        instance.run
+
+        exit_code = 0
+
+      # This is how rspec catches exit()
+      rescue SystemExit => e
+        exit_code = e.status
+      ensure
+        Chef::Log.use_log_devices(old_loggers)
+        Chef::Log.level = old_log_level
+        Chef::Config[:cache_options] = old_cache_options
+      end
+
+      KnifeResult.new(stdout.string, stderr.string, exit_code)
+    end
+  end
+
+  private
+
+  class KnifeResult
+    def initialize(stdout, stderr, exit_code)
+      @stdout = stdout
+      @stderr = stderr
+      @exit_code = exit_code
+    end
+
+    attr_reader :stdout
+    attr_reader :stderr
+    attr_reader :exit_code
+
+    def should_fail(*args)
+      expected = {}
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          expected.merge!(arg)
+        elsif arg.is_a?(Integer)
+          expected[:exit_code] = arg
+        else
+          expected[:stderr] = arg
+        end
+      end
+      expected[:exit_code] = 1 if !expected[:exit_code]
+      should_result_in(expected)
+    end
+
+    def should_succeed(*args)
+      expected = {}
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          expected.merge!(arg)
+        else
+          expected[:stdout] = arg
+        end
+      end
+      should_result_in(expected)
+    end
+
+    private
+
+    def should_result_in(expected)
+      expected[:stdout] = '' if !expected[:stdout]
+      expected[:stderr] = '' if !expected[:stderr]
+      expected[:exit_code] = 0 if !expected[:exit_code]
+      # TODO make this go away
+      stderr_actual = @stderr.sub(/^WARNING: No knife configuration file found\n/, '')
+
+      if expected[:stderr].is_a?(Regexp)
+        stderr_actual.should =~ expected[:stderr]
+      else
+        stderr_actual.should == expected[:stderr]
+      end
+      stdout_actual = @stdout
+      if Chef::Platform.windows?
+        stderr_actual = stderr_actual.gsub("\r\n", "\n")
+        stdout_actual = stdout_actual.gsub("\r\n", "\n")
+      end
+      @exit_code.should == expected[:exit_code]
+      if expected[:stdout].is_a?(Regexp)
+        stdout_actual.should =~ expected[:stdout]
+      else
+        stdout_actual.should == expected[:stdout]
+      end
+    end
+  end
+end

data/spec/support/shared/unit/execute_resource.rb

@@ -0,0 +1,125 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Tyler Cloke (<tyler@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, 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'
+
+shared_examples_for "an execute resource" do
+
+  before(:each) do
+    @resource = execute_resource
+  end
+
+  it "should create a new Chef::Resource::Execute" do
+    @resource.should be_a_kind_of(Chef::Resource)
+    @resource.should be_a_kind_of(Chef::Resource::Execute)
+  end
+
+  it "should set the command to the first argument to new" do
+    @resource.command.should eql(resource_instance_name)
+  end
+
+  it "should accept an array on instantiation, too" do
+    resource = Chef::Resource::Execute.new(%w{something else})
+    resource.should be_a_kind_of(Chef::Resource)
+    resource.should be_a_kind_of(Chef::Resource::Execute)
+    resource.command.should eql(%w{something else})
+  end
+
+  it "should accept a string for the command to run" do
+    @resource.command "something"
+    @resource.command.should eql("something")
+  end
+
+  it "should accept an array for the command to run" do
+    @resource.command %w{something else}
+    @resource.command.should eql(%w{something else})
+  end
+
+  it "should accept a string for the cwd" do
+    @resource.cwd "something"
+    @resource.cwd.should eql("something")
+  end
+
+  it "should accept a hash for the environment" do
+    test_hash = { :one => :two }
+    @resource.environment(test_hash)
+    @resource.environment.should eql(test_hash)
+  end
+
+  it "allows the environment to be specified with #env" do
+    @resource.should respond_to(:env)
+  end
+
+  it "should accept a string for the group" do
+    @resource.group "something"
+    @resource.group.should eql("something")
+  end
+
+  it "should accept an integer for the group" do
+    @resource.group 1
+    @resource.group.should eql(1)
+  end
+
+  it "should accept an array for the execution path" do
+    @resource.path ["woot"]
+    @resource.path.should eql(["woot"])
+  end
+
+  it "should accept an integer for the return code" do
+    @resource.returns 1
+    @resource.returns.should eql(1)
+  end
+
+  it "should accept an integer for the timeout" do
+    @resource.timeout 1
+    @resource.timeout.should eql(1)
+  end
+
+  it "should accept a string for the user" do
+    @resource.user "something"
+    @resource.user.should eql("something")
+  end
+
+  it "should accept an integer for the user" do
+    @resource.user 1
+    @resource.user.should eql(1)
+  end
+
+  it "should accept a string for creates" do
+    @resource.creates "something"
+    @resource.creates.should eql("something")
+  end
+
+  describe "when it has cwd, environment, group, path, return value, and a user" do
+    before do
+      @resource.command("grep")
+      @resource.cwd("/tmp/")
+      @resource.environment({ :one => :two })
+      @resource.group("legos")
+      @resource.path(["/var/local/"])
+      @resource.returns(1)
+      @resource.user("root")
+    end
+
+    it "returns the command as its identity" do
+      @resource.identity.should == "grep"
+    end
+  end
+end
+