motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/plugin_manager_spec.rb

@@ -0,0 +1,724 @@
+require 'spec_helper'
+
+describe MotherBrain::PluginManager do
+  describe "ClassMethods" do
+    subject { described_class }
+
+    describe "::new" do
+      context "when 'remote_loading' is disabled" do
+        before(:each) do
+          described_class.any_instance.stub(eager_loading?: false)
+        end
+
+        it "has a nil value for eager_load_timer" do
+          subject.new.eager_load_timer.should be_nil
+        end
+      end
+
+      context "when 'eager_loading' is enabled" do
+        before(:each) do
+          described_class.any_instance.stub(eager_loading?: true )
+        end
+
+        it "sets a Timer for remote_load_timer" do
+          subject.any_instance.should_receive(:load_all_remote)
+
+          subject.new.eager_load_timer.should be_a(Timers::Timer)
+        end
+      end
+    end
+  end
+
+  subject { described_class.new }
+
+  describe "#install" do
+    let(:plugin) { double(name: "rspec", version: "1.2.3") }
+    let(:plugin_install_path) { subject.install_path_for(plugin) }
+
+    before { subject.stub_chain(:chef_connection, :cookbook, :download) }
+
+    context "when the remote contains the plugin and it is not installed" do
+      before do
+        subject.stub(:find).with(plugin.name, plugin.version, remote: true).and_return(plugin)
+        subject.stub(:find).with(plugin.name, plugin.version, remote: false).and_return(nil)
+      end
+
+      it "searches for the plugin of the given name/version on the remote" do
+        subject.should_receive(:find).with(plugin.name, plugin.version, remote: true).and_return(plugin)
+
+        subject.install(plugin.name, plugin.version)
+      end
+
+      it "returns the found plugin" do
+        expect(subject.install(plugin.name, plugin.version)).to eq(plugin)
+      end
+
+      it "downloads the cookbook containing the plugin to the Berkshelf" do
+        cookbook_resource = double
+        subject.stub_chain(:chef_connection, :cookbook).and_return(cookbook_resource)
+        cookbook_resource.should_receive(:download).with(plugin.name, plugin.version, plugin_install_path)
+
+        subject.install(plugin.name, plugin.version)
+      end
+
+      it "adds the plugin to the list of plugins" do
+        subject.install(plugin.name, plugin.version)
+
+        expect(subject.list).to include(plugin)
+      end
+    end
+
+    context "when the remote does not have a plugin of the given name/version" do
+      before { subject.should_receive(:find).with(plugin.name, plugin.version, remote: true).and_return(nil) }
+
+      it "raises a PluginNotFound error" do
+        expect { subject.install(plugin.name, plugin.version) }.to raise_error(MB::PluginNotFound)
+      end
+    end
+  end
+
+  describe "#install_path_for" do
+    let(:plugin) { double(name: "rspec", version: "1.2.3") }
+
+    it "returns a Pathname" do
+      expect(subject.install_path_for(plugin)).to be_a(Pathname)
+    end
+  end
+
+  describe "#uninstall" do
+    let(:plugin) { double(name: "rpsec", version: "1.2.3") }
+    let(:plugin_install_path) { subject.install_path_for(plugin) }
+
+    before do
+      subject.add(plugin)
+      FileUtils.mkdir_p(plugin_install_path)
+    end
+
+    it "returns the uninstalled plugin" do
+      expect(subject.uninstall(plugin.name, plugin.version)).to eql(plugin)
+    end
+
+    it "removes the plugin from the plugins list" do
+      subject.uninstall(plugin.name, plugin.version)
+
+      expect(subject.list).to_not include(plugin)
+    end
+
+    it "removes the plugin and it's cookbook from disk" do
+      subject.uninstall(plugin.name, plugin.version)
+
+      expect(plugin_install_path).to_not exist
+    end
+
+    context "when the plugin of the given name/version is not installed" do
+      before { subject.stub(:find).with(plugin.name, plugin.version, remote: false).and_return(nil) }
+
+      it "returns nil" do
+        expect(subject.uninstall(plugin.name, plugin.version)).to be_nil
+      end
+    end
+  end
+
+  describe "#latest" do
+    let(:name) { "apple" }
+    let(:version) { "2.0.0" }
+
+    let(:plugin) do
+      double('plugin', name: name, version: version)
+    end
+
+    before(:each) do
+      subject.stub(list: [plugin])
+    end
+
+    it "searches the latest version of the plugin matching the given name" do
+      subject.should_receive(:find).with(name, version, remote: false).and_return(plugin)
+      subject.latest(name).should eql(plugin)
+    end
+
+    context "when no suitable plugin can be found" do
+      before(:each) do
+        subject.stub(list: [])
+      end
+
+      it "returns nil" do
+        subject.latest(name).should be_nil
+      end
+    end
+  end
+
+  describe "#load_all" do
+    let(:count) { 3 }
+
+    before(:each) do
+      subject.clear_plugins
+      paths = Array.new
+
+      count.times do
+        paths << generate_cookbook(SecureRandom.hex(16), with_plugin: true)
+      end
+
+      MB::Berkshelf.stub(:cookbooks).and_return(paths)
+    end
+
+    it "sends a load message to self with each plugin found in the berkshelf" do
+      subject.should_receive(:load_installed).with(anything, force: false).exactly(count).times
+
+      subject.load_all
+    end
+
+    it "has a plugin for each plugin in the paths" do
+      subject.load_all
+
+      subject.list.should have(count).items
+      subject.list.should each be_a(MB::Plugin)
+    end
+
+    context "when 'remote_loading' is enabled" do
+      before(:each) do
+        subject.stub(eager_loading?: true)
+      end
+
+      it "calls #load_all_remote" do
+        subject.should_receive(:load_all_remote)
+        subject.load_all
+      end
+    end
+  end
+
+  describe "#load_all_installed" do
+    before do
+      install_cookbook("ruby", "1.2.3", with_plugin: true)
+      install_cookbook("ruby", "2.0.0", with_plugin: true)
+      install_cookbook("elixir", "1.3.4", with_plugin: false)
+    end
+
+    it "loads each plugin found in the Berkshelf" do
+      subject.load_all_installed
+      expect(subject.list).to have(2).items
+      expect(subject).to have_plugin("ruby", "1.2.3")
+      expect(subject).to have_plugin("ruby", "2.0.0")
+    end
+  end
+
+  describe "#load_all_remote" do
+    before do
+      described_class.any_instance.stub(async_loading?: false)
+      chef_cookbook("ruby", "1.2.3", with_plugin: true)
+      chef_cookbook("ruby", "2.0.0", with_plugin: false)
+      chef_cookbook("elixir", "1.3.4", with_plugin: true)
+    end
+
+    it "loads each plugin found on the Chef Server" do
+      subject.load_all_remote
+      expect(subject.list).to have(2).items
+      expect(subject).to have_plugin("ruby", "1.2.3")
+      expect(subject).to have_plugin("elixir", "1.3.4")
+    end
+
+    context "given a value for :name" do
+      it "only loads each plugin found on the Chef Server matching the given name" do
+        subject.load_all_remote(name: "ruby")
+        expect(subject.list).to have(1).item
+        expect(subject).to have_plugin("ruby", "1.2.3")
+      end
+    end
+  end
+
+  describe "#load_installed" do
+    let(:plugin) do
+      metadata = MB::CookbookMetadata.new do
+        name 'apple'
+        version '1.0.0'
+      end
+      MB::Plugin.new(metadata)
+    end
+
+    let(:path) { '/tmp/one/apple-1.0.0' }
+
+    before(:each) do
+      MB::Plugin.stub(:from_path).with(path).and_return(plugin)
+    end
+
+    it "adds an instantiated plugin to the hash of plugins" do
+      subject.load_installed(path)
+
+      subject.list.should include(plugin)
+    end
+  end
+
+  describe "#load_remote" do
+    let(:name) { "nginx" }
+    let(:version) { "1.2.0" }
+    let(:resource) do
+      Ridley::CookbookObject.new(double('client'))
+    end
+
+    before(:each) do
+      subject.ridley.stub_chain(:cookbook, :find).and_return(resource)
+    end
+
+    context "when the cookbook doesn't contain a motherbrain plugin" do
+      before(:each) { resource.stub(has_motherbrain_plugin?: false) }
+
+      it "returns nil if resource doesn't contain a motherbrain plugin" do
+        subject.load_remote(name, version).should be_nil
+      end
+    end
+
+    context "when the cookbook contains a motherbrain plugin" do
+      before(:each) { resource.stub(has_motherbrain_plugin?: true) }
+      let(:temp_dir) { MB::FileSystem.tmpdir }
+
+      context "and the files are transferred successfully" do
+        before(:each) do
+          File.write(File.join(temp_dir, MB::Plugin::PLUGIN_FILENAME), "# blank plugin")
+
+          MB::FileSystem.stub(tmpdir: temp_dir)
+
+          resource.stub(:download_file).and_return(true)
+
+          json_metadata = File.read(fixtures_path.join('cb_metadata.json'))
+          resource.stub_chain(:metadata, :to_json).and_return(json_metadata)
+        end
+
+        it "adds the plugin to the set of plugins" do
+          subject.load_remote(name, version)
+
+          subject.list.should have(1).item
+        end
+
+        it "cleans up the generated temporary files" do
+          subject.load_remote(name, version)
+
+          File.exist?(temp_dir).should be_false
+        end
+      end
+
+      context "when the plugin is not downloaded successfully" do
+        before(:each) { resource.stub(:download_file).and_return(nil) }
+
+        it "returns nil" do
+          subject.load_remote(name, version).should be_nil
+        end
+      end
+    end
+
+    context "when the remote does not have a cookbook of the given name/version" do
+      before(:each) { subject.ridley.stub_chain(:cookbook, :find).and_return(nil) }
+
+      it "returns nil" do
+        subject.load_remote(name, version).should be_nil
+      end
+    end
+  end
+
+  describe "#add" do
+    let(:plugin) do
+      metadata = MB::CookbookMetadata.new do
+        name 'apple'
+        version '1.0.0'
+      end
+      MB::Plugin.new(metadata)
+    end
+
+    it "returns the added plugin" do
+      subject.add(plugin).should eql(plugin)
+    end
+
+    it "adds the plugin to the Set of plugins" do
+      subject.add(plugin)
+
+      subject.list.should include(plugin)
+    end
+
+    context "when the plugin is already added" do
+      it "returns nil" do
+        subject.add(plugin)
+
+        subject.add(plugin).should be_nil
+      end
+
+      context "when given 'true' for the ':force' option" do
+        it "adds the plugin anyway" do
+          subject.add(plugin)
+
+          subject.add(plugin, force: true).should eql(plugin)
+        end
+
+        it "doesn't add a duplicate plugin" do
+          subject.add(plugin)
+          subject.add(plugin)
+
+          subject.list.should have(1).item
+        end
+      end
+    end
+  end
+
+  describe "#async_loading?" do
+    context "if the plugin manager is configured for async loading" do
+      before(:each) do
+        MB::Application.config.plugin_manager.stub(async_loading: true)
+      end
+
+      it "returns true" do
+        subject.async_loading?.should be_true
+      end
+    end
+
+    context "if the plugin manager is not configured for async loading" do
+      before(:each) do
+        MB::Application.config.plugin_manager.stub(async_loading: false)
+      end
+
+      it "returns false" do
+        subject.async_loading?.should be_false
+      end
+    end
+  end
+
+  describe "#find" do
+    let(:one) do
+      metadata = MB::CookbookMetadata.new do
+        name 'apple'
+        version '1.0.0'
+      end
+      MB::Plugin.new(metadata)
+    end
+    let(:two) do
+      metadata = MB::CookbookMetadata.new do
+        name 'apple'
+        version '2.0.0'
+      end
+      MB::Plugin.new(metadata)
+    end
+    let(:three) do
+      metadata = MB::CookbookMetadata.new do
+        name 'orange'
+        version '2.0.0'
+      end
+      MB::Plugin.new(metadata)
+    end
+
+    before(:each) do
+      subject.add(one)
+      subject.add(two)
+      subject.add(three)
+    end
+
+    it "returns the plugin of the given name and version" do
+      subject.find(one.name, one.version).should eql(one)
+    end
+
+    it "returns nil if the plugin of a given name and version is not found" do
+      subject.find("glade", "3.2.4").should be_nil
+    end
+
+    it "returns the latest if a version is not passed" do
+      subject.find("apple").should eq(two)
+    end
+  end
+
+  describe "#for_environment" do
+    let(:plugin_id) { "rspec-test" }
+    let(:environment_id) { "rspec-testenv" }
+    let(:environment) do
+      double('environment',
+        name: environment_id,
+        cookbook_versions: {
+          plugin_id => ">= 1.2.3"
+        }
+      )
+    end
+    let(:options) do
+      {
+        remote: true
+      }
+    end
+
+    context "when the environment exists" do
+      before(:each) do
+        environment_manager.should_receive(:find).with(environment_id).and_return(environment)
+      end
+
+      it "attempts to satisfy the environment's plugin (cookbook) constraint" do
+        subject.should_receive(:satisfy).with(plugin_id, ">= 1.2.3", options)
+        subject.for_environment(plugin_id, environment_id, options)
+      end
+    end
+
+    context "when the environment exists but does not have a lock" do
+      before do
+        environment.stub(cookbook_versions: Hash.new)
+        environment_manager.should_receive(:find).with(environment_id).and_return(environment)
+      end
+
+      it "satisfies the environment using a wildcard constraint (>= 0.0.0)" do
+        subject.should_receive(:satisfy).with(plugin_id, ">= 0.0.0", options)
+        subject.for_environment(plugin_id, environment_id, options)
+      end
+    end
+
+    context "when the environment does not exist" do
+      before(:each) do
+        environment_manager.should_receive(:find).with(environment_id).
+          and_raise(MB::EnvironmentNotFound.new(environment_id))
+      end
+
+      it "raises an EnvironmentNotFound error" do
+        expect {
+          subject.for_environment(plugin_id, environment_id)
+        }.to raise_error(MB::EnvironmentNotFound)
+      end
+    end
+  end
+
+  describe "#for_run_list_entry" do
+    let(:cookbook_name)  { "foobook" }
+    let(:recipe_name)    { "server"  }
+    let(:version)        { "1.1.2"   }
+    let(:environment)    { "foo"     }
+
+    let(:run_list_entry) { "recipe[#{cookbook_name}::#{recipe_name}]" }
+    let(:run_list_entry_with_version) { run_list_entry.sub(/\]/, "@#{version}]") }
+
+    describe "with run list version" do
+      it "should use the run list version definition" do
+        subject.should_receive(:find).with(cookbook_name, version, {})
+        subject.for_run_list_entry(run_list_entry_with_version)
+      end
+
+      it "should use the run list version even if an environment is provided" do
+        subject.should_receive(:find).with(cookbook_name, version, {})
+        subject.for_run_list_entry(run_list_entry_with_version, environment)
+      end
+    end
+
+    describe "with environment" do
+      it "should use the environment version lock" do
+        subject.should_receive(:for_environment).with(cookbook_name, environment, {})
+        subject.for_run_list_entry(run_list_entry, environment)
+      end
+    end
+
+    it "should find the plugin" do
+      subject.should_receive(:find).with(cookbook_name, nil, {})
+      subject.for_run_list_entry(run_list_entry)
+    end
+  end
+
+  describe "#clear_plugins" do
+    let(:plugin) do
+      metadata = MB::CookbookMetadata.new do
+        name 'apple'
+        version '1.0.0'
+      end
+      MB::Plugin.new(metadata)
+    end
+
+    it "clears any loaded plugins" do
+      subject.add(plugin)
+      subject.clear_plugins
+
+      subject.list.should be_empty
+    end
+  end
+
+  describe "#list" do
+    it "returns an Array of plugins" do
+      result = subject.list
+
+      result.should be_a(Array)
+      result.should each be_a(MB::Plugin)
+    end
+
+    context "given 'true' for the :remote option" do
+      it "loads the remote plugins before returning" do
+        subject.should_receive(:load_all_remote)
+
+        subject.list(remote: true)
+      end
+    end
+  end
+
+  describe "#satisfy" do
+    let(:plugin_id) { "rspec-test" }
+    let(:versions) do
+      [
+        "1.0.0",
+        "1.2.3",
+        "1.3.0"
+      ]
+    end
+    let(:options) do
+      {
+        remote: false
+      }
+    end
+
+    let(:constraint) { ">= 1.2.3" }
+    let(:plugin) { double('plugin', name: plugin_id, version: '1.3.0') }
+
+    context "when given a non-wildcard, non-equality constraint" do
+      before(:each) do
+        subject.should_receive(:versions).with(plugin_id, options[:remote]).and_return(versions)
+      end
+
+      it "returns the best plugin for the given constraint" do
+        subject.should_receive(:find).with(plugin_id, "1.3.0", remote: false).and_return(plugin)
+        subject.satisfy(plugin_id, constraint, options).should eql(plugin)
+      end
+    end
+
+    context "when given a constraint containing an eqluality operator" do
+      let(:constraint) { "= 1.0.0" }
+
+      it "does not attempt to get a list of all versions" do
+        subject.should_not_receive(:versions)
+
+        subject.satisfy(plugin_id, constraint, options)
+      end
+
+      context "when the :remote option is set to true" do
+        before { options[:remote] = true }
+
+        it "attempts to eagerly load a plugin of the same name/version from the remote" do
+          subject.should_receive(:load_remote).with(plugin_id, "1.0.0")
+
+          subject.satisfy(plugin_id, constraint, options)
+        end
+      end
+    end
+
+    context "when given a wild card constraint (>= 0.0.0)" do
+      let(:constraint) { ">= 0.0.0" }
+
+      it "returns the latest plugin" do
+        subject.should_receive(:latest).with(plugin_id, options).and_return(plugin)
+
+        subject.satisfy(plugin_id, constraint, options).should eql(plugin)
+      end
+    end
+  end
+
+  describe "#installed_versions" do
+    before { MB::Berkshelf.stub(cookbooks_path: fixtures_path) }
+
+    context "when the installed cookbooks have at least one version containing a plugin" do
+      it "returns an array containing a string for each" do
+        versions = subject.installed_versions("myface")
+        versions.should have(1).item
+        versions.should each be_a(String)
+      end
+    end
+
+    context "when the installed cookbooks does not have a version containing a plugin" do
+      it "returns an empty array" do
+        subject.installed_versions("nginx").should be_empty
+      end
+    end
+  end
+
+  describe "#remote_versions" do
+    let(:name) { "nginx" }
+    let(:chef_connection) { double('chef-connection') }
+
+    let(:versions) do
+      [
+        "1.0.0",
+        "2.0.0"
+      ]
+    end
+
+    before do
+      subject.stub(chef_connection: chef_connection)
+      chef_connection.stub_chain(:cookbook, :versions).with(name).and_return(versions)
+    end
+
+    it "attempts to load a plugin for every version of the cookbook present on the chef server" do
+      versions.each do |version|
+        subject.should_receive(:load_remote).with(name, version).and_return(nil)
+      end
+
+      subject.remote_versions(name)
+    end
+
+    context "when the cookbook versions on the remote contain a plugin" do
+      before do
+        versions.each do |version|
+          subject.should_receive(:load_remote).with(name, version).and_return(double(version: version))
+        end
+      end
+
+      it "returns an array of strings including the versions" do
+        subject.remote_versions(name).should include(*versions)
+      end
+    end
+
+    context "when the cookbook versions on the remote do not contain a plugin" do
+      before do
+        versions.each do |version|
+          subject.should_receive(:load_remote).with(name, version).and_return(nil)
+        end
+      end
+
+      it "returns an empty array of strings" do
+        subject.remote_versions(name).should be_empty
+      end
+    end
+
+    context "when the remote chef server does not contain any cookbooks of the given name" do
+      let(:versions) { Array.new }
+
+      before do
+        chef_connection.stub_chain(:cookbook, :versions).with(name).and_return(versions)
+      end
+
+      it "returns an empty array" do
+        subject.remote_versions(name).should be_empty
+      end
+    end
+  end
+
+  describe "#versions" do
+    let(:name) { "nginx" }
+    let(:installed_versions) { [ "1.2.3", "2.0.0" ] }
+    let(:remote_versions) { [ "3.0.0" ] }
+
+    context "when given 'false' for the remote argument" do
+      before do
+        subject.should_not_receive(:remote_versions)
+        subject.should_receive(:installed_versions).with(name).and_return(installed_versions)
+      end
+
+      it "returns only the installed plugins" do
+        expect(subject.versions(name, false)).to eql(installed_versions)
+      end
+    end
+
+    context "when given 'true' for the remote argument" do
+      before do
+        subject.should_receive(:remote_versions).with(name).and_return(remote_versions)
+        subject.should_receive(:installed_versions).with(name).and_return(installed_versions)
+      end
+
+      it "includes the remote versions" do
+        expect(subject.versions(name, true)).to include(*remote_versions)
+      end
+
+      it "includes the installed versions" do
+        expect(subject.versions(name, true)).to include(*installed_versions)
+      end
+
+      context "when no plugins are found" do
+        let(:remote_versions) { Array.new }
+        let(:installed_versions) { Array.new }
+
+        it "raises a PluginNotFound error" do
+          expect { subject.versions(name, true) }.to raise_error(MB::PluginNotFound)
+        end
+      end
+    end
+  end
+end