librarian-puppet-maestrodev 0.9.7

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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,319 @@
+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