librarian-puppet-maestrodev 0.9.7.5 → 0.9.8.1

data/vendor/librarian/spec/unit/action/ensure_spec.rb

@@ -1,37 +0,0 @@
-require "tmpdir"
-
-require "librarian/error"
-require "librarian/action/ensure"
-
-module Librarian
-  describe Action::Ensure do
-
-    let(:env) { mock }
-    let(:action) { described_class.new(env) }
-
-    before do
-      env.stub(:specfile_name) { "Specfile" }
-    end
-
-    describe "#run" do
-
-      context "when the environment does not know its project path" do
-        before { env.stub(:project_path) { nil } }
-
-        it "should raise an error describing that the specfile is mising" do
-          expect { action.run }.to raise_error(Error, "Cannot find Specfile!")
-        end
-      end
-
-      context "when the environment knows its project path" do
-        before { env.stub(:project_path) { Dir.tmpdir } }
-
-        it "should not raise an error" do
-          expect { action.run }.to_not raise_error
-        end
-      end
-
-    end
-
-  end
-end

data/vendor/librarian/spec/unit/action/install_spec.rb

@@ -1,111 +0,0 @@
-require "librarian/error"
-require "librarian/action/install"
-
-module Librarian
-  describe Action::Install do
-
-    let(:env) { mock(:specfile_name => "Specfile", :lockfile_name => "Specfile.lock") }
-    let(:action) { described_class.new(env) }
-
-    describe "#run" do
-
-      describe "behavior" do
-
-        describe "checking preconditions" do
-
-          context "when the specfile is missing" do
-            before do
-              env.stub_chain(:specfile_path, :exist?) { false }
-            end
-
-            it "should raise an error explaining that the specfile is missing" do
-              expect { action.run }.to raise_error(Error, "Specfile missing!")
-            end
-          end
-
-          context "when the specfile is present but the lockfile is missing" do
-            before do
-              env.stub_chain(:specfile_path, :exist?) { true }
-              env.stub_chain(:lockfile_path, :exist?) { false }
-            end
-
-            it "should raise an error explaining that the lockfile is missing" do
-              expect { action.run }.to raise_error(Error, "Specfile.lock missing!")
-            end
-          end
-
-          context "when the specfile and lockfile are present but inconsistent" do
-            before do
-              env.stub_chain(:specfile_path, :exist?) { true }
-              env.stub_chain(:lockfile_path, :exist?) { true }
-              action.stub(:spec_consistent_with_lock?) { false }
-            end
-
-            it "should raise an error explaining the inconsistenty" do
-              expect { action.run }.to raise_error(Error, "Specfile and Specfile.lock are out of sync!")
-            end
-          end
-
-          context "when the specfile and lockfile are present and consistent" do
-            before do
-              env.stub_chain(:specfile_path, :exist?) { true }
-              env.stub_chain(:lockfile_path, :exist?) { true }
-              action.stub(:spec_consistent_with_lock?) { true }
-              action.stub(:perform_installation)
-            end
-
-            it "should not raise an error" do
-              expect { action.run }.to_not raise_error
-            end
-          end
-
-        end
-
-        describe "performing the install" do
-
-          def mock_manifest(i)
-            double(:name => "manifest-#{i}")
-          end
-
-          let(:manifests) { 3.times.map{|i| mock_manifest(i)} }
-          let(:sorted_manifests) { 4.times.map{|i| mock_manifest(i + 3)} }
-          let(:install_path) { mock }
-
-          before do
-            env.stub(:install_path) { install_path }
-            action.stub(:check_preconditions)
-            action.stub_chain(:lock, :manifests) { manifests }
-          end
-
-          after do
-            action.run
-          end
-
-          it "should sort and install the manifests" do
-            ManifestSet.should_receive(:sort).with(manifests).exactly(:once).ordered { sorted_manifests }
-
-            install_path.stub(:exist?) { false }
-            install_path.should_receive(:mkpath).exactly(:once).ordered
-
-            sorted_manifests.each do |manifest|
-              manifest.should_receive(:install!).exactly(:once).ordered
-            end
-          end
-
-          it "should recreate the install path if it already exists" do
-            action.stub(:sorted_manifests) { sorted_manifests }
-            action.stub(:install_manifests)
-
-            install_path.stub(:exist?) { true }
-            install_path.should_receive(:rmtree)
-            install_path.should_receive(:mkpath)
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-end

data/vendor/librarian/spec/unit/config/database_spec.rb

@@ -1,319 +0,0 @@
-require "fileutils"
-require "pathname"
-require "yaml"
-
-require "fakefs/spec_helpers"
-
-require "librarian/config/database"
-
-describe Librarian::Config::Database do
-  include FakeFS::SpecHelpers
-
-  def write_yaml!(path, *yamlables)
-    dir = File.dirname(path)
-    FileUtils.mkpath(dir) unless File.directory?(dir)
-    File.open(path, "wb"){|f| yamlables.each{|y| YAML.dump(y, f)}}
-  end
-
-  let(:adapter_name) { "gem" }
-
-  let(:env) { { } }
-  let(:pwd) { Pathname("/tmp") }
-  let(:home) { Pathname("~").expand_path }
-  let(:project_path) { nil }
-  let(:specfile_name) { nil }
-  let(:global) { home.join(".librarian/gem/config") }
-  let(:local) { pwd.join(".librarian/gem/config") }
-  let(:specfile) { pwd.join("Gemfile") }
-
-  before do
-    FileUtils.mkpath(pwd)
-    FileUtils.touch(specfile)
-  end
-
-  let(:database) do
-    described_class.new(adapter_name,
-      :env => env,
-      :pwd => pwd.to_s,
-      :home => home.to_s,
-      :project_path => project_path,
-      :specfile_name => specfile_name
-    )
-  end
-
-  context "when a key is given globally" do
-    let(:key) { "jam" }
-    let(:value) { "jelly" }
-    let(:raw_key) { "LIBRARIAN_GEM_JAM" }
-
-    before do
-      write_yaml! global, raw_key => value
-    end
-
-    it "should have the key globally" do
-      database.global[key].should == value
-    end
-
-    it "should not have the key in the env" do
-      database.env[key].should be_nil
-    end
-
-    it "should not have the key locally" do
-      database.local[key].should be_nil
-    end
-
-    it "should have the key generally" do
-      database[key].should == value
-    end
-  end
-
-  context "when a key is set globally" do
-    let(:key) { "jam" }
-    let(:value) { "jelly" }
-    let(:raw_key) { "LIBRARIAN_GEM_JAM" }
-
-    before do
-      database.global[key] = value
-    end
-
-    it "should have the key globally" do
-      database.global[key].should == value
-    end
-
-    it "should not have the key in the env" do
-      database.env[key].should be_nil
-    end
-
-    it "should not have the key locally" do
-      database.local[key].should be_nil
-    end
-
-    it "should have the key generally" do
-      database[key].should == value
-    end
-
-    it "should persist the key" do
-      data = YAML.load_file(global)
-
-      data.should == {raw_key => value}
-    end
-  end
-
-  context "when the key is set and unset globally" do
-    let(:key) { "jam" }
-    let(:value) { "jelly" }
-    let(:raw_key) { "LIBRARIAN_GEM_JAM" }
-
-    before do
-      database.global[key] = value
-      database.global[key] = nil
-    end
-
-    it "should not have the key globally" do
-      database.global[key].should be_nil
-    end
-
-    it "should not have the key in the env" do
-      database.env[key].should be_nil
-    end
-
-    it "should not have the key locally" do
-      database.local[key].should be_nil
-    end
-
-    it "should not have the key generally" do
-      database[key].should be_nil
-    end
-
-    it "should unpersist the key" do
-      File.should_not exist global
-    end
-  end
-
-  context "when a key is given in the env" do
-    let(:key) { "jam" }
-    let(:value) { "jelly" }
-    let(:raw_key) { "LIBRARIAN_GEM_JAM" }
-
-    #override
-    let(:env) { {raw_key => value} }
-
-    it "should not have the key globally" do
-      database.global[key].should be_nil
-    end
-
-    it "should have the key in the env" do
-      database.env[key].should == value
-    end
-
-    it "should not have the key locally" do
-      database.local[key].should be_nil
-    end
-
-    it "should have the key generally" do
-      database[key].should == value
-    end
-  end
-
-  context "when a key is given locally" do
-    let(:key) { "jam" }
-    let(:value) { "jelly" }
-    let(:raw_key) { "LIBRARIAN_GEM_JAM" }
-
-    before do
-      write_yaml! local, raw_key => value
-    end
-
-    it "should not have the key globally" do
-      database.global[key].should be_nil
-    end
-
-    it "should not have the key in the env" do
-      database.env[key].should be_nil
-    end
-
-    it "should have the key locally" do
-      database.local[key].should == value
-    end
-
-    it "should have the key generally" do
-      database[key].should == value
-    end
-  end
-
-  context "when a key is set locally" do
-    let(:key) { "jam" }
-    let(:value) { "jelly" }
-    let(:raw_key) { "LIBRARIAN_GEM_JAM" }
-
-    before do
-      database.local[key] = value
-    end
-
-    it "should not have the key globally" do
-      database.global[key].should be_nil
-    end
-
-    it "should not have the key in the env" do
-      database.env[key].should be_nil
-    end
-
-    it "should have the key locally" do
-      database.local[key].should == value
-    end
-
-    it "should have the key generally" do
-      database[key].should == value
-    end
-
-    it "should persist the key" do
-      data = YAML.load_file(local)
-
-      data.should == {raw_key => value}
-    end
-  end
-
-  context "when the key is set and unset locally" do
-    let(:key) { "jam" }
-    let(:value) { "jelly" }
-    let(:raw_key) { "LIBRARIAN_GEM_JAM" }
-
-    before do
-      database.local[key] = value
-      database.local[key] = nil
-    end
-
-    it "should not have the key globally" do
-      database.global[key].should be_nil
-    end
-
-    it "should not have the key in the env" do
-      database.env[key].should be_nil
-    end
-
-    it "should not have the key locally" do
-      database.local[key].should be_nil
-    end
-
-    it "should not have the key generally" do
-      database[key].should be_nil
-    end
-
-    it "should unpersist the key" do
-      File.should_not exist local
-    end
-  end
-
-  context "setting malformatted keys" do
-    it "should ban caps" do
-      expect { database.global["JAM"] = "jelly" }.
-        to raise_error Librarian::Error, %[key not permitted: "JAM"]
-    end
-
-    it "should ban double dots" do
-      expect { database.global["jam..jam"] = "jelly" }.
-        to raise_error Librarian::Error, %[key not permitted: "jam..jam"]
-    end
-  end
-
-  context "setting banned keys" do
-    it  "should ban the specfile key" do
-      expect { database.global["gemfile"] = "jelly" }.
-        to raise_error Librarian::Error, %[key not permitted: "gemfile"]
-    end
-
-    it  "should ban the global-config key" do
-      expect { database.global["config"] = "jelly" }.
-        to raise_error Librarian::Error, %[key not permitted: "config"]
-    end
-  end
-
-  context "project_path" do
-    context "by default" do
-      it "should give the default project path" do
-        database.project_path.should == Pathname("/tmp")
-      end
-    end
-
-    context "when the specfile is set in the env" do
-      let(:env) { {"LIBRARIAN_GEM_GEMFILE" => "/non/sense/path/to/Sillyfile"} }
-
-      it "should give the project path from the env-set specfile" do
-        database.project_path.should == Pathname("/non/sense/path/to")
-      end
-    end
-  end
-
-  context "specfile_path" do
-    context "by default" do
-      it "should give the default specfile path" do
-        database.specfile_path.should == specfile
-      end
-    end
-
-    context "when set in the env" do
-      let(:env) { {"LIBRARIAN_GEM_GEMFILE" => "/non/sense/path/to/Sillyfile"} }
-
-      it "should give the given specfile path" do
-        database.specfile_path.should == Pathname("/non/sense/path/to/Sillyfile")
-      end
-    end
-
-    context "when the project_path is assigned" do
-      let(:project_path) { "/non/sense/path/to" }
-
-      it "should give the assigned specfile path" do
-        database.specfile_path.should == Pathname("/non/sense/path/to/Gemfile")
-      end
-    end
-
-    context "when the specfile_name is assigned" do
-      let(:specfile_name) { "Sillyfile" }
-
-      it "should give the assigned specfile path" do
-        database.specfile_path.should == Pathname("/tmp/Sillyfile")
-      end
-    end
-  end
-
-end