chefspec-chef 9.3.4

data/spec/unit/macros_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe ChefSpec::API::Stubs do
+  describe "#stub_command" do
+    let(:command_stub) { double("command") }
+
+    it "adds the command to the command registry" do
+      allow(ChefSpec::Stubs::CommandStub).to receive(:new).and_return(command_stub)
+      stub_command('echo "hello"')
+
+      expect(ChefSpec::Stubs::CommandRegistry.stubs).to include(command_stub)
+    end
+  end
+
+  describe "#stub_search" do
+    let(:search_stub) { double("search") }
+
+    it "adds the query to the search registry" do
+      allow(ChefSpec::Stubs::SearchStub).to receive(:new).and_return(search_stub)
+      stub_search(:node, "*:*")
+
+      expect(ChefSpec::Stubs::SearchRegistry.stubs).to include(search_stub)
+    end
+  end
+
+  describe "#stub_data_bag" do
+    let(:data_bag_stub) { double("data_bag") }
+
+    it "adds the query to the data_bag registry" do
+      allow(ChefSpec::Stubs::DataBagStub).to receive(:new).and_return(data_bag_stub)
+      stub_data_bag(:users)
+
+      expect(ChefSpec::Stubs::DataBagRegistry.stubs).to include(data_bag_stub)
+    end
+  end
+
+  describe "#stub_data_bag_item" do
+    let(:data_bag_item_stub) { double("data_bag_item") }
+
+    it "adds the query to the data_bag_item registry" do
+      allow(ChefSpec::Stubs::DataBagItemStub).to receive(:new).and_return(data_bag_item_stub)
+      stub_data_bag_item(:users, "id")
+
+      expect(ChefSpec::Stubs::DataBagItemRegistry.stubs).to include(data_bag_item_stub)
+    end
+  end
+
+  describe "#stub_node" do
+    it "returns a Chef::Node" do
+      expect(stub_node).to be_a(Chef::Node)
+    end
+
+    it "defaults the node name to `node.example`" do
+      node = stub_node
+      expect(node.name).to eq("node.example")
+    end
+
+    it "sets the node name when given" do
+      node = stub_node("example.com")
+      expect(node.name).to eq("example.com")
+    end
+
+    it "sets the automatic attributes" do
+      node = stub_node
+      expect(node.automatic).to eq(Fauxhai.mock.data)
+    end
+
+    it "sets the automatic attributes with ohai overrides" do
+      node = stub_node("node.example", ohai: { ipaddress: "1.2.3.4" })
+      expect(node["ipaddress"]).to eq("1.2.3.4")
+    end
+
+    it "sets the automatic attributes for a specific platform and version" do
+      node = stub_node("node.example", platform: "ubuntu", version: "18.04")
+      expect(node.automatic).to eq(Fauxhai.mock(platform: "ubuntu", version: "18.04").data)
+    end
+
+    it "sets the automatic attributes from a JSON data path" do
+      allow(File).to receive(:exist?).with("/path/to/json").and_return(true)
+      allow(File).to receive(:read).with("/path/to/json").and_return('{ "ipaddress": "1.2.3.4" }')
+      node = stub_node("node.example", path: "/path/to/json")
+      expect(node["ipaddress"]).to eq("1.2.3.4")
+    end
+
+    it "yields a block" do
+      expect { |block| stub_node(&block) }.to yield_with_args(Chef::Node)
+    end
+  end
+end
+
+describe "nginx::source" do
+  describe "#described_cookbook" do
+    describe "nginx::source" do
+      it "returns the name of the cookbook" do
+        expect(described_cookbook).to eq("nginx")
+      end
+
+      context "in a nested context" do
+        it "still returns the name of the cookbook" do
+          expect(described_cookbook).to eq("nginx")
+        end
+      end
+    end
+  end
+
+  describe "#described_recipe" do
+    describe "nginx::source" do
+      it "returns the cookbook::recipe" do
+        expect(described_recipe).to eq("nginx::source")
+      end
+
+      context "in a nested context" do
+        it "still retrns the cookbook::recipe" do
+          expect(described_recipe).to eq("nginx::source")
+        end
+      end
+    end
+  end
+end

data/spec/unit/matchers/do_nothing_matcher.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe ChefSpec::Matchers::DoNothingMatcher do
+  pending
+end

data/spec/unit/matchers/include_any_recipe_matcher_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe ChefSpec::Matchers::IncludeAnyRecipeMatcher do
+  let(:node) { double("Chef::Node", run_list: run_list) }
+  let(:run_list) { double("Chef::RunList", run_list_items: run_list_items) }
+  let(:run_list_items) { [run_list_item_one] }
+  let(:run_list_item_one) { double("Chef::RunList::RunListItem", name: "one") }
+  let(:run_list_item_two) { double("Chef::RunList::RunListItem", name: "two") }
+  let(:loaded_recipes) { %w{one} }
+  let(:chef_run) { double("chef run", run_context: { loaded_recipes: loaded_recipes, node: node }) }
+
+  subject { described_class.new }
+
+  describe "#failure_message" do
+    it "has the right value" do
+      subject.matches?(chef_run)
+      expect(subject.failure_message).to eq("expected to include any recipe")
+    end
+  end
+
+  describe "#failure_message_when_negated" do
+    it "has the right value" do
+      subject.matches?(chef_run)
+      expect(subject.failure_message_when_negated).to eq("expected not to include any recipes")
+    end
+  end
+
+  describe "#description" do
+    it "has the right value" do
+      subject.matches?(chef_run)
+      expect(subject.description).to eq("include any recipe")
+    end
+  end
+
+  describe "#matches?" do
+    context "when 0 recipes are included" do
+      let(:loaded_recipes) { %w{one} }
+
+      it "returns false" do
+        expect(subject.matches?(chef_run)).to be false
+      end
+    end
+
+    context "when at least one recipe is included" do
+      let(:loaded_recipes) { %w{one two} }
+
+      it "returns true" do
+        expect(subject.matches?(chef_run)).to be true
+      end
+    end
+  end
+end

data/spec/unit/matchers/include_recipe_matcher_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe ChefSpec::Matchers::IncludeRecipeMatcher do
+  let(:chef_run) { double("chef run", run_context: { loaded_recipes: %w{one two three} }) }
+  subject { described_class.new("one::default") }
+
+  describe "#failure_message" do
+    it "has the right value" do
+      subject.matches?(chef_run)
+      expect(subject.failure_message)
+        .to eq(%q{expected ["one::default", "two::default", "three::default"] to include "one::default"})
+    end
+  end
+
+  describe "#failure_message_when_negated" do
+    it "has the right value" do
+      subject.matches?(chef_run)
+      expect(subject.failure_message_when_negated)
+        .to eq(%q{expected "one::default" to not be included})
+    end
+  end
+
+  describe "#description" do
+    it "has the right value" do
+      subject.matches?(chef_run)
+      expect(subject.description).to eq(%q{include recipe "one::default"})
+    end
+  end
+
+  it "matches when the recipe is included" do
+    expect(subject.matches?(chef_run)).to be_truthy
+  end
+
+  it "does not match when the recipe is not included" do
+    failure = described_class.new("nope")
+    expect(failure.matches?(chef_run)).to be_falsy
+  end
+end

data/spec/unit/matchers/link_to_matcher_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe ChefSpec::Matchers::LinkToMatcher do
+  let(:from) { "/var/www" }
+  let(:to)   { "/var/html" }
+  let(:link) do
+    Chef::Resource::Link.new(from).tap do |link|
+      link.to(to)
+      link.perform_action(:create)
+    end
+  end
+  subject { described_class.new(to) }
+
+  describe "#failure_message" do
+    it "has the right value" do
+      subject.matches?(link)
+      expect(subject.failure_message)
+        .to eq(%Q{expected "link[#{from}]" to link to "#{to}" but was "#{to}"})
+    end
+  end
+
+  describe "#failure_message_when_negated" do
+    it "has the right value" do
+      subject.matches?(link)
+      expect(subject.failure_message_when_negated)
+        .to eq(%Q{expected "link[#{from}]" to not link to "#{to}"})
+    end
+  end
+
+  describe "#description" do
+    it "has the right value" do
+      subject.matches?(link)
+      expect(subject.description).to eq(%Q{link to "#{to}"})
+    end
+  end
+
+  context "when the link is correct" do
+    it "matches" do
+      expect(subject.matches?(link)).to be_truthy
+    end
+
+    it "adds the link to the coverage report" do
+      expect(ChefSpec::Coverage).to receive(:cover!).with(link)
+      subject.matches?(link)
+    end
+  end
+
+  context "when the link is not correct" do
+    subject { described_class.new("/nope/bad/path/bro") }
+
+    it "does not match" do
+      expect(subject.matches?(link)).to be_falsy
+    end
+  end
+end

data/spec/unit/matchers/notifications_matcher_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe ChefSpec::Matchers::NotificationsMatcher do
+  subject { described_class.new("execute[install]") }
+  let(:package) do
+    double("package",
+      name: "package",
+      to_s: "package[foo]",
+      is_a?: true,
+      performed_action?: true,
+      immediate_notifications: [],
+      delayed_notifications: [],
+      before_notifications: [])
+  end
+
+  describe "#failure_message" do
+    it "has the right value" do
+      subject.matches?(package)
+      expect(subject.failure_message)
+        .to include %{expected "package[foo]" to notify "execute[install]", but did not.}
+    end
+  end
+
+  describe "#failure_message_when_negated" do
+    it "has the right value" do
+      subject.matches?(package)
+      expect(subject.failure_message_when_negated)
+        .to eq %{expected "package[foo]" to not notify "execute[install]", but it did.}
+    end
+  end
+
+  describe "#description" do
+    it "has the right value" do
+      subject.matches?(package)
+      expect(subject.description)
+        .to eq %{notify "execute[install]"}
+    end
+  end
+end

data/spec/unit/matchers/render_file_matcher_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe ChefSpec::Matchers::RenderFileMatcher do
+  let(:path) { "/tmp/thing" }
+  let(:file) { double("file", to: path, to_s: "file[#{path}]", performed_action?: true) }
+  let(:chef_run) { double("chef run", find_resource: file) }
+  subject { described_class.new(path) }
+
+  describe "#with_content" do
+    it "accepts do/end syntax" do
+      subject.matches?(chef_run)
+      expect(
+        subject.with_content do |content|
+          "Does not raise ArgumentError"
+        end.expected_content.first.call
+      ).to eq("Does not raise ArgumentError")
+    end
+  end
+
+  describe "#failure_message" do
+    it "has the right value" do
+      subject.matches?(chef_run)
+      expect(subject.failure_message)
+        .to eq(%Q{expected Chef run to render "#{path}"})
+    end
+  end
+
+  describe "#failure_message_when_negated" do
+    it "has the right value" do
+      subject.matches?(chef_run)
+      expect(subject.failure_message_when_negated)
+        .to eq(%Q{expected file "#{path}" to not be in Chef run})
+    end
+  end
+
+  describe "#description" do
+    it "has the right value" do
+      subject.matches?(chef_run)
+      expect(subject.description).to eq(%Q{render file "#{path}"})
+    end
+
+    it "has the right value when with_content is chained" do
+      subject.matches?(chef_run)
+      expect(
+        subject.with_content("foo").with_content("bar").description
+      ).to eq(%Q{render file "#{path}" with content "foo" with content "bar"})
+    end
+  end
+
+  context "when the file is correct" do
+    it "matches" do
+      expect(subject.matches?(chef_run)).to be_truthy
+    end
+
+    it "adds the resource to the coverage report" do
+      expect(ChefSpec::Coverage).to receive(:cover!).with(file)
+      subject.matches?(chef_run)
+    end
+  end
+
+  context "when the file is not correct" do
+    it "does not match" do
+      allow(chef_run).to receive(:find_resource).and_return(nil)
+      failure = described_class.new("nope")
+      expect(failure.matches?(chef_run)).to be_falsy
+    end
+  end
+end

data/spec/unit/matchers/resource_matcher_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe ChefSpec::Matchers::ResourceMatcher do
+  pending
+end

data/spec/unit/matchers/state_attrs_matcher_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe ChefSpec::Matchers::StateAttrsMatcher do
+  subject { described_class.new(%i{a b}) }
+
+  context "when the resource does not exist" do
+    let(:resource) { nil }
+    before { subject.matches?(resource) }
+
+    it "does not match" do
+      expect(subject).to_not be_matches(resource)
+    end
+
+    it "has the correct description" do
+      expect(subject.description).to eq("have state attributes [:a, :b]")
+    end
+
+    it "has the correct failure message for should" do
+      expect(subject.failure_message).to include <<-EOH.gsub(/^ {8}/, "")
+        expected _something_ to have state attributes, but the _something_ you gave me was nil!
+        Ensure the resource exists before making assertions:
+
+          expect(resource).to be
+      EOH
+    end
+
+    it "has the correct failure message for should not" do
+      expect(subject.failure_message_when_negated).to include <<-EOH.gsub(/^ {8}/, "")
+        expected _something_ to not have state attributes, but the _something_ you gave me was nil!
+        Ensure the resource exists before making assertions:
+
+          expect(resource).to be
+      EOH
+    end
+  end
+
+  context "when the resource exists" do
+    let(:klass) { double("class", state_attrs: %i{a b}) }
+    let(:resource) { double("resource", class: klass) }
+    before { subject.matches?(resource) }
+
+    it "has the correct description" do
+      expect(subject.description).to eq("have state attributes [:a, :b]")
+    end
+
+    it "has the correct failure message for should" do
+      expect(subject.failure_message).to eq("expected [:a, :b] to equal [:a, :b]")
+    end
+
+    it "has the correct failure message for should not" do
+      expect(subject.failure_message_when_negated).to eq("expected [:a, :b] to not equal [:a, :b]")
+    end
+
+    it "matches when the state attributes are correct" do
+      expect(subject).to be_matches(resource)
+    end
+
+    it "does not match when the state attributes are incorrect" do
+      allow(klass).to receive(:state_attrs).and_return(%i{c d})
+      expect(subject).to_not be_matches(resource)
+    end
+
+    it "does not match when partial state attribute are incorrect" do
+      allow(klass).to receive(:state_attrs).and_return(%i{b c})
+      expect(subject).to_not be_matches(resource)
+    end
+  end
+end

data/spec/unit/matchers/subscribes_matcher_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe ChefSpec::Matchers::SubscribesMatcher do
+  subject { described_class.new("execute[install]") }
+  let(:runner) { double("runner", find_resource: nil) }
+  let(:run_context) { double("run_context", node: node) }
+  let(:node) { double("node", runner: runner) }
+  let(:package) do
+    double("package",
+      name: "package",
+      to_s: "package[foo]",
+      run_context: run_context)
+  end
+
+  context "when no resource is found" do
+    describe "#failure_message" do
+      it "has the right value" do
+        subject.matches?(package)
+        expect(subject.failure_message)
+          .to include %{expected _something_ to notify "package[foo]", but the _something_ you gave me was nil! If you are running a test like:}
+      end
+    end
+  end
+
+  context "when the resource exists" do
+    let(:execute) do
+      double("execute",
+        name: "execute",
+        to_s: "execute[install]",
+        immediate_notifications: [],
+        delayed_notifications: [],
+        before_notifications: [])
+    end
+
+    before do
+      allow(runner).to receive(:find_resource).and_return(execute)
+    end
+
+    describe "#failure_message" do
+      it "has the right value" do
+        subject.matches?(package)
+        expect(subject.failure_message)
+          .to include %{expected "execute[install]" to notify "package[foo]", but did not.}
+      end
+    end
+
+    describe "#failure_message_when_negated" do
+      it "has the right value" do
+        subject.matches?(package)
+        expect(subject.failure_message_when_negated)
+          .to eq %{expected "execute[install]" to not notify "package[foo]", but it did.}
+      end
+    end
+  end
+
+  describe "#description" do
+    it "has the right value" do
+      subject.matches?(package)
+      expect(subject.description)
+        .to eq %{notify "package[foo]"}
+    end
+  end
+end

data/spec/unit/renderer_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+describe ChefSpec::Renderer do
+  describe ".initialize" do
+    it "accepts two arguments and assigns their instance variables" do
+      instance = described_class.new("runner", "resource")
+      expect(instance.chef_run).to eq("runner")
+      expect(instance.resource).to eq("resource")
+    end
+  end
+
+  let(:chef_run) { double("chef_run", { node: "node" }) }
+  let(:resource) { double("resource", { cookbook: "cookbook", source: "source", variables: {} }) }
+  subject { described_class.new(chef_run, resource) }
+
+  describe "#content" do
+    before do
+      allow(subject).to receive(:content_from_cookbook_file).and_return("cookbook_file content")
+      allow(subject).to receive(:content_from_file).and_return("file content")
+      allow(subject).to receive(:content_from_template).and_return("template content")
+    end
+
+    context "when the resource is a cookbook_file" do
+      it "renders the cookbook_file content" do
+        allow(resource).to receive(:resource_name).and_return("cookbook_file")
+        expect(subject.content).to eq("cookbook_file content")
+      end
+    end
+
+    context "when the resource is a file" do
+      it "renders the file content" do
+        allow(resource).to receive(:resource_name).and_return("file")
+        expect(subject.content).to eq("file content")
+      end
+    end
+
+    context "when the resource is a template" do
+      it "renders the template content" do
+        allow(resource).to receive(:resource_name).and_return("template")
+        expect(subject.content).to eq("template content")
+      end
+    end
+
+    context "when the resource is not a file type" do
+      it "returns nil" do
+        allow(resource).to receive(:resource_name).and_return("service")
+        expect(subject.content).to be_nil
+      end
+    end
+  end
+
+  describe "content_from_template" do
+    it "renders the template by extending modules for rendering paritals within the template" do
+      cookbook_collection = {}
+      cookbook_collection["cookbook"] = double("", { preferred_filename_on_disk_location: "/template/location" } )
+      allow(subject).to receive(:cookbook_collection).with("node").and_return(cookbook_collection)
+      allow(subject).to receive(:template_finder)
+
+      allow(resource).to receive(:helper_modules).and_return([Module.new])
+      allow(resource).to receive(:resource_name).and_return("template")
+
+      chef_template_context = double("context", { render_template: "rendered template content", update: nil })
+      allow(Chef::Mixin::Template::TemplateContext).to receive(:new).and_return(chef_template_context)
+
+      expect(chef_template_context).to receive(:_extend_modules).with(resource.helper_modules)
+      expect(subject.content).to eq("rendered template content")
+    end
+  end
+end

data/spec/unit/server_runner_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe ChefSpec::ServerRunner do
+  context "when the RSpec config is set" do
+    it "does not create a tmpdir" do
+      allow(RSpec.configuration).to receive(:file_cache_path)
+        .and_return("/foo/bar")
+      expect(ChefSpec::FileCachePathProxy).to_not receive(:instance)
+      described_class.new
+    end
+  end
+
+  context "when the RSpec config is not set" do
+    it "creates and returns a tmpdir" do
+      expect(ChefSpec::FileCachePathProxy).to receive(:instance)
+        .and_call_original
+      described_class.new
+      expect(Chef::Config[:file_cache_path]).to match(/chefspec/)
+    end
+
+    it "uses the same path" do
+      val = ChefSpec::FileCachePathProxy.instance.file_cache_path
+      expect(described_class.new.options[:file_cache_path]).to eq(val)
+      expect(described_class.new.options[:file_cache_path]).to eq(val)
+      expect(described_class.new.options[:file_cache_path]).to eq(val)
+    end
+  end
+end