chefspec-chef 9.3.4

data/lib/chefspec/stubs/search_stub.rb

@@ -0,0 +1,25 @@
+require_relative "stub"
+
+module ChefSpec
+  module Stubs
+    class SearchStub < Stub
+      attr_reader :block
+      attr_reader :query
+      attr_reader :type
+
+      def initialize(type, query = "*:*", &block)
+        @type  = type.to_s
+        @query = query
+        @block = block
+      end
+
+      def signature
+        if @block
+          "stub_search(#{@type.inspect}, #{@query.inspect}) { # Ruby code }"
+        else
+          "stub_search(#{@type.inspect}, #{@query.inspect}).and_return(#{@value})"
+        end
+      end
+    end
+  end
+end

data/lib/chefspec/stubs/stub.rb

@@ -0,0 +1,38 @@
+module ChefSpec
+  module Stubs
+    class Stub
+      attr_reader :value
+
+      def and_return(value)
+        @value = value
+        self
+      end
+
+      def and_raise(exception)
+        @block = Proc.new { raise exception }
+        self
+      end
+
+      def result
+        if @block
+          recursively_mashify(@block.call)
+        else
+          recursively_mashify(@value)
+        end
+      end
+
+      private
+
+      def recursively_mashify(thing)
+        case thing
+        when Array
+          thing.collect { |item| recursively_mashify(item) }
+        when Hash
+          Mash.from_hash(thing)
+        else
+          thing
+        end
+      end
+    end
+  end
+end

data/lib/chefspec/util.rb

@@ -0,0 +1,58 @@
+module ChefSpec
+  module Util
+    extend self
+
+    #
+    # Covert the given CaMelCaSeD string to under_score. Graciously borrowed
+    # from http://stackoverflow.com/questions/1509915.
+    #
+    # @param [String] string
+    #   the string to use for transformation
+    #
+    # @return [String]
+    #
+    def underscore(string)
+      string
+        .to_s
+        .gsub(/::/, "/")
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr("-", "_")
+        .downcase
+    end
+
+    #
+    # Convert an underscored string to it's camelcase equivalent constant.
+    #
+    # @param [String] string
+    #   the string to convert
+    #
+    # @return [String]
+    #
+    def camelize(string)
+      string
+        .to_s
+        .split("_")
+        .map(&:capitalize)
+        .join
+    end
+
+    #
+    # Truncate the given string to a certain number of characters.
+    #
+    # @param [String] string
+    #   the string to truncate
+    # @param [Hash] options
+    #   the list of options (such as +length+)
+    #
+    def truncate(string, options = {})
+      length = options[:length] || 30
+
+      if string.length > length
+        string[0..length - 3] + "..."
+      else
+        string
+      end
+    end
+  end
+end

data/lib/chefspec/version.rb

@@ -0,0 +1,3 @@
+module ChefSpec
+  VERSION = "9.3.4".freeze
+end

data/lib/chefspec/zero_server.rb

@@ -0,0 +1,142 @@
+require "chef_zero/server"
+
+module ChefSpec
+  # Rather than create a ChefZero instance per test case, simply create one
+  # ChefZero instance and reset it for every test case.
+  class ZeroServer
+    class << self
+      extend Forwardable
+      def_delegators :instance, :setup!, :teardown!, :reset!, :upload_cookbooks!, :server, :load_data, :nuke!
+    end
+
+    include Singleton
+
+    attr_reader :server
+
+    # Create the ChefZero Server
+    def initialize
+      nuke!
+    end
+
+    #
+    # Start the ChefZero Server
+    #
+    def setup!
+      @server.start_background unless @server.running?
+    end
+
+    #
+    # Remove all the data we just loaded from the ChefZero server
+    #
+    def reset!
+      if RSpec.configuration.server_runner_clear_cookbooks
+        @server.clear_data
+        @cookbooks_uploaded = false
+      else
+        # If we don't want to do a full clear, iterate through each value that we
+        # set and manually remove it.
+        @data_loaded.each do |key, names|
+          if key == "data"
+            names.each { |n| @server.data_store.delete_dir(["organizations", "chef", key, n]) }
+          else
+            names.each { |n| @server.data_store.delete(["organizations", "chef", key, n]) }
+          end
+        end
+      end
+      @data_loaded = {}
+    end
+
+    #
+    # Really reset everything and reload the configuration
+    #
+    def nuke!
+      @server = ChefZero::Server.new(
+        # Set the log level from RSpec, defaulting to warn
+        log_level:  RSpec.configuration.log_level || :warn,
+        port: RSpec.configuration.server_runner_port,
+
+        # Set the data store
+        data_store: data_store(RSpec.configuration.server_runner_data_store)
+      )
+      @cookbooks_uploaded = false
+      @data_loaded = {}
+    end
+
+    #
+    # Teardown the ChefZero Server
+    #
+    def teardown!
+      @server.stop if @server.running?
+    end
+
+    #
+    # Upload the cookbooks to the Chef Server.
+    #
+    def upload_cookbooks!
+      return if @cookbooks_uploaded
+
+      loader = Chef::CookbookLoader.new(Chef::Config[:cookbook_path])
+      loader.load_cookbooks
+      cookbook_uploader_for(loader).upload_cookbooks
+      @cookbooks_uploaded = true
+    end
+
+    #
+    # Load (and track) data sent to the server
+    #
+    # @param [String] name
+    #   the name or id of the item to load
+    # @param [String, Symbol] key
+    #   the key to load
+    # @param [Hash] data
+    #   the data for the object, which will be converted to JSON and uploaded
+    #   to the server
+    #
+    def load_data(name, key, data)
+      @data_loaded[key] ||= []
+      @data_loaded[key] << name
+      @server.load_data({ key => { name => data } })
+    end
+
+    private
+
+    #
+    # The uploader for the cookbooks.
+    #
+    # @param [Chef::CookbookLoader] loader
+    #   the Chef cookbook loader
+    #
+    # @return [Chef::CookbookUploader]
+    #
+    def cookbook_uploader_for(loader)
+      Chef::CookbookUploader.new(loader.cookbooks)
+    end
+
+    #
+    # Generate the DataStore object to be passed in to the ChefZero::Server object
+    #
+    def data_store(option)
+      require "chef_zero/data_store/default_facade"
+
+      store = case option
+              when :in_memory
+                require "chef_zero/data_store/memory_store_v2"
+                ChefZero::DataStore::MemoryStoreV2.new
+              when :on_disk
+                require "tmpdir" unless defined?(Dir.mktmpdir)
+                require "chef_zero/data_store/raw_file_store"
+                ChefZero::DataStore::RawFileStore.new(Dir.mktmpdir)
+              else
+                raise ArgumentError, ":#{option} is not a valid server_runner_data_store option. Please use either :in_memory or :on_disk."
+              end
+
+      ChefZero::DataStore::DefaultFacade.new(store, "chef", true)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:suite) { ChefSpec::ZeroServer.setup! }
+  config.after(:each) { ChefSpec::ZeroServer.reset! }
+  config.after(:suite)  { ChefSpec::ZeroServer.teardown! }
+end

data/lib/chefspec.rb

@@ -0,0 +1,75 @@
+require "rspec"
+
+module ChefSpec
+  #
+  # Defines a new runner method on the Chef runner.
+  #
+  # @param [Symbol] resource_name
+  #   the name of the resource to define a method
+  #
+  # @return [self]
+  #
+  def define_matcher(resource_name)
+    matchers[resource_name.to_sym] = Proc.new do |identity|
+      find_resource(resource_name, identity)
+    end
+
+    self
+  end
+  module_function :define_matcher
+
+  #
+  # The source root of the ChefSpec gem. This is useful when requiring files
+  # that are relative to the root of the project.
+  #
+  # @return [Pathname]
+  #
+  def root
+    @root ||= Pathname.new(File.expand_path("..", __dir__))
+  end
+  module_function :root
+
+  protected
+
+  #
+  # The list of custom defined matchers.
+  #
+  # @return [Hash<String, Proc>]
+  #
+  def matchers
+    @matchers ||= {}
+  end
+  module_function :matchers
+end
+
+require_relative "chefspec/extensions"
+
+require_relative "chefspec/mixins/normalize"
+
+require_relative "chefspec/stubs/command_registry"
+require_relative "chefspec/stubs/command_stub"
+require_relative "chefspec/stubs/data_bag_item_registry"
+require_relative "chefspec/stubs/data_bag_item_stub"
+require_relative "chefspec/stubs/data_bag_registry"
+require_relative "chefspec/stubs/data_bag_stub"
+require_relative "chefspec/stubs/registry"
+require_relative "chefspec/stubs/stub"
+require_relative "chefspec/stubs/search_registry"
+require_relative "chefspec/stubs/search_stub"
+
+require_relative "chefspec/api"
+require_relative "chefspec/cacher"
+require_relative "chefspec/coverage"
+require_relative "chefspec/errors"
+require_relative "chefspec/expect_exception"
+require_relative "chefspec/formatter"
+require_relative "chefspec/matchers"
+require_relative "chefspec/renderer"
+require_relative "chefspec/rspec"
+require_relative "chefspec/server_runner"
+require_relative "chefspec/solo_runner"
+require_relative "chefspec/runner"
+require_relative "chefspec/util"
+require_relative "chefspec/version"
+
+require_relative "chefspec/deprecations"

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require "chefspec"
+require "support/hash"
+
+ChefSpec::Coverage.start! do
+  set_template "table.erb"
+end
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+  config.filter_run(focus: true)
+  config.run_all_when_everything_filtered = true
+end

data/spec/support/hash.rb

@@ -0,0 +1,35 @@
+#
+# An extension of a Hash that allows mash-style like lookups.
+#
+# @private
+#
+class Hash
+  # Like, seriously Windows?
+  undef_method(:timeout) if method_defined?(:timeout)
+
+  #
+  # Monkey-patch to allow mash-style look ups for tests
+  #
+  def method_missing(m, *args, &block)
+    if key?(m.to_sym)
+      self[m.to_sym]
+    elsif key?(m.to_s)
+      self[m.to_s]
+    else
+      super
+    end
+  end
+
+  #
+  # Monkey-patch to stdlib Hash to correspond to Mash-style lookup
+  #
+  # @see Hash#respond_to?
+  #
+  def respond_to?(m, include_private = false)
+    if key?(m.to_sym) || key?(m.to_s)
+      true
+    else
+      super
+    end
+  end
+end

data/spec/unit/cacher_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+require "chefspec/cacher"
+
+describe ChefSpec::Cacher do
+  let(:klass) do
+    Class.new(RSpec::Core::ExampleGroup) do
+      extend ChefSpec::Cacher
+
+      def self.metadata
+        { parent_example_group: { location: "spec" } }
+      end
+    end
+  end
+
+  let(:cache) { described_class.class_variable_get(:@@cache) }
+  let(:preserve_cache) { false }
+
+  before(:each) { described_class.class_variable_set(:@@cache, {}) unless preserve_cache }
+
+  describe "cached" do
+    it "lazily defines the results for the cache" do
+      klass.cached(:chef_run)
+      expect(klass).to be_method_defined(:chef_run)
+    end
+
+    it "adds the item to the cache when called" do
+      runner = double(:runner)
+      klass.cached(:chef_run) { runner }
+      klass.new.chef_run
+
+      expect(cache[Thread.current.object_id]).to have_key("spec.chef_run")
+      expect(cache[Thread.current.object_id]["spec.chef_run"]).to eq(runner)
+    end
+
+    context "when multithreaded environment" do
+      it "is thread safe" do
+        (1..2).each do |n|
+          Thread.new do
+            klass.cached(:chef_run) { n }
+            expect(klass.new.chef_run).to eq(n)
+          end.join
+        end
+      end
+    end
+
+    context "when example groups are defined by looping" do
+      let(:preserve_cache) { true }
+
+      %w{first second third}.each do |iteration|
+        context "on the #{iteration} iteration" do
+          context "in caching context" do
+            cached(:cached_iteration) { iteration }
+            it "caches the iteration for this context" do
+              expect(cached_iteration).to eq iteration
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "cached!" do
+    it "loads the value at runtime" do
+      expect(klass).to receive(:cached).with(:chef_run).once
+      expect(klass).to receive(:before).once
+
+      klass.cached!(:chef_run) {}
+    end
+  end
+end

data/spec/unit/coverage/filters_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+# Note: These specs don't use Berkshelf code directly as this project doesn't
+# have a direct dependency on Berkshelf and loading it would impact the
+# perfance of these specs. While not ideal, the test doubles provide enough of
+# a standin for Berkshelf to exercise the `#matches?` behavior.
+describe ChefSpec::Coverage::BerkshelfFilter do
+  let(:dependencies) do
+    [double("Berkshelf::Dependency", metadata?: true, name: "cookbookery")]
+  end
+  let(:berksfile) { double("Berkshelf::Berksfile", dependencies: dependencies) }
+  let(:resource) { Chef::Resource.new("theone") }
+  subject { described_class.new(berksfile) }
+
+  describe "#matches?" do
+    it "returns truthy if resource source_line is nil" do
+      expect(subject.matches?(resource)).to be_truthy
+    end
+
+    context "when resource#source_line is under target cookbook" do
+      it "normal unix path returns truthy" do
+        resource.source_line =
+          "/path/to/cookbooks/nope/recipes/default.rb:22"
+        expect(subject.matches?(resource)).to be_truthy
+      end
+
+      it "normal windows path returns truthy" do
+        resource.source_line =
+          'C:\\path\\to\\cookbooks\\nope\\recipes\\default.rb:22'
+        expect(subject.matches?(resource)).to be_truthy
+      end
+
+      it "mixed windows path returns truthy" do
+        resource.source_line =
+          'C:\\path\\to\\cookbooks/nope/recipes/default.rb:22'
+        expect(subject.matches?(resource)).to be_truthy
+      end
+    end
+
+    context "when resource#source_line is not under target cookbook" do
+      it "normal unix path returns falsey" do
+        resource.source_line =
+          "/path/to/cookbooks/cookbookery/recipes/default.rb:22"
+        expect(subject.matches?(resource)).to be_falsey
+      end
+
+      it "normal windows path returns falsey" do
+        resource.source_line =
+          'C:\\path\\to\\cookbooks\\cookbookery\\recipes\\default.rb:22'
+        expect(subject.matches?(resource)).to be_falsey
+      end
+
+      it "mixed windows path returns falsey" do
+        resource.source_line =
+          'C:\\path\\to\\cookbooks/cookbookery/recipes/default.rb:22'
+        expect(subject.matches?(resource)).to be_falsey
+      end
+    end
+  end
+end

data/spec/unit/deprecations_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe ChefSpec::Runner do
+  before do
+    allow_any_instance_of(ChefSpec::SoloRunner)
+      .to receive(:dry_run?)
+      .and_return(true)
+    allow(ChefSpec::Runner).to receive(:deprecated)
+  end
+
+  describe "#define_runner_method" do
+    before do
+      allow(ChefSpec).to receive(:define_matcher)
+    end
+
+    it "prints a deprecation" do
+      expect(ChefSpec::Runner).to receive(:deprecated)
+        .with("`ChefSpec::Runner.define_runner_method' is deprecated."\
+          " It is being used in the my_custom_resource resource matcher." \
+          " Please use `ChefSpec.define_matcher' instead.")
+      ChefSpec::Runner.define_runner_method(:my_custom_resource)
+    end
+
+    it "calls ChefSpec#define_matcher" do
+      expect(ChefSpec).to receive(:define_matcher).with(:my_custom_resource).once
+      ChefSpec::Runner.define_runner_method(:my_custom_resource)
+    end
+
+  end
+end
+
+describe ChefSpec::Server do
+  before do
+    allow(ChefSpec::Server).to receive(:deprecated)
+  end
+
+  it "prints a deprecation for any method called" do
+    expect(ChefSpec::Server).to receive(:deprecated)
+      .with("`ChefSpec::Server.any_method' is deprecated. There is no longer" \
+        " a global Chef Server instance. Please use a ChefSpec::SoloRunner" \
+        " instead. More documentation can be found in the ChefSpec README.")
+    expect {
+      ChefSpec::Server.any_method
+    }.to raise_error(ChefSpec::Error::NoConversionError)
+  end
+
+  it "raises non-conversion error for any method called" do
+    expect { ChefSpec::Server.any_method }
+      .to raise_error(ChefSpec::Error::NoConversionError)
+  end
+
+end

data/spec/unit/errors_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+module ChefSpec::Error
+  describe CommandNotStubbed do
+    let(:instance) { described_class.new(args: ["cat"]) }
+
+    it "raises an exception with the correct message" do
+      instance
+      expect { raise instance }.to( raise_error { |error|
+        expect(error).to be_a(described_class)
+        expect(error.message).to eq <<-EOH.gsub(/^ {10}/, "")
+          Executing a real command is disabled. Unregistered command:
+
+              command("cat")
+
+          You can stub this command with:
+
+              stub_command("cat").and_return(...)
+        EOH
+      })
+    end
+  end
+
+  describe CookbookPathNotFound do
+    let(:instance) { described_class.new }
+
+    it "raises an exception with the correct message" do
+      expect { raise instance }.to(raise_error { |error|
+        expect(error).to be_a(described_class)
+        expect(error.message).to eq <<-EOH.gsub(/^ {10}/, "")
+          I could not find or infer a cookbook_path from your current working directory.
+          Please make sure you put your specs (tests) under a directory named 'spec' or
+          manually set the cookbook path in the RSpec configuration.
+        EOH
+      })
+    end
+  end
+
+  describe GemLoadError do
+    let(:instance) { described_class.new(gem: "bacon", name: "bacon") }
+
+    it "raises an exception with the correct message" do
+      expect { raise instance }.to( raise_error { |error|
+        expect(error).to be_a(described_class)
+        expect(error.message).to eq <<-EOH.gsub(/^ {10}/, "")
+          I could not load the 'bacon' gem! You must have the gem installed
+          on your local system before you can use the bacon plugin.
+          You can install bacon by running:
+
+              gem install bacon
+
+          or add bacon to your Gemfile and run the `bundle` command to install.
+        EOH
+      })
+    end
+  end
+end

data/spec/unit/expect_exception_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe ChefSpec::ExpectException do
+  context "when there have been no `raise_error` matchers" do
+    subject { described_class.new(Exception) }
+
+    it "does not match" do
+      allow(RSpec::Matchers::BuiltIn::RaiseError).to receive(:last_run).and_return(nil)
+      expect(subject.expected?).to be_falsy
+    end
+  end
+
+  context "when the last error does not match the expected type" do
+    subject { described_class.new(RuntimeError) }
+
+    it "does not match" do
+      last_error = double("last error", last_error_for_chefspec: ArgumentError)
+      allow(RSpec::Matchers::BuiltIn::RaiseError).to receive(:last_run).and_return(last_error)
+      expect(subject.expected?).to be_falsy
+    end
+  end
+
+  context "when the last error matches the expected type" do
+    subject { described_class.new(RuntimeError) }
+
+    it "does not match" do
+      last_error = double("last error", last_error_for_chefspec: RuntimeError)
+      allow(RSpec::Matchers::BuiltIn::RaiseError).to receive(:last_run).and_return(last_error)
+      expect(subject.expected?).to be_truthy
+    end
+  end
+end