librarian-puppet 0.0.1.pre

data/vendor/librarian/spec/functional/chef/source/site_spec.rb

@@ -0,0 +1,215 @@
+require 'pathname'
+require 'json'
+require 'webmock'
+
+require 'librarian'
+require 'librarian/helpers'
+require 'librarian/action/resolve'
+require 'librarian/action/install'
+require 'librarian/chef'
+
+module Librarian
+  module Chef
+    module Source
+      describe Site do
+
+        include WebMock::API
+
+        let(:project_path) do
+          project_path = Pathname.new(__FILE__).expand_path
+          project_path = project_path.dirname until project_path.join("Rakefile").exist?
+          project_path
+        end
+        let(:tmp_path) { project_path.join("tmp/spec/chef/site-source") }
+        let(:sample_path) { tmp_path.join("sample") }
+        let(:sample_metadata) do
+          Helpers.strip_heredoc(<<-METADATA)
+            version "0.6.5"
+          METADATA
+        end
+
+        let(:api_url) { "http://site.cookbooks.com" }
+
+        let(:sample_index_data) do
+          {
+            "name" => "sample",
+            "versions" => [
+              "#{api_url}/cookbooks/sample/versions/0_6_5"
+            ]
+          }
+        end
+        let(:sample_0_6_5_data) do
+          {
+            "version" => "0.6.5",
+            "file" => "#{api_url}/cookbooks/sample/versions/0_6_5/file.tar.gz"
+          }
+        end
+
+        # depends on repo_path being defined in each context
+        let(:env) { Environment.new(:project_path => repo_path) }
+
+        before :all do
+          sample_path.rmtree if sample_path.exist?
+          sample_path.mkpath
+          sample_path.join("metadata.rb").open("wb") { |f| f.write(sample_metadata) }
+          Dir.chdir(sample_path.dirname) do
+            system "tar --create --gzip --file sample.tar.gz #{sample_path.basename}"
+          end
+        end
+
+        before do
+          stub_request(:get, "#{api_url}/cookbooks/sample").
+            to_return(:body => JSON.dump(sample_index_data))
+
+          stub_request(:get, "#{api_url}/cookbooks/sample/versions/0_6_5").
+            to_return(:body => JSON.dump(sample_0_6_5_data))
+
+          stub_request(:get, "#{api_url}/cookbooks/sample/versions/0_6_5/file.tar.gz").
+            to_return(:body => sample_path.dirname.join("sample.tar.gz").read)
+        end
+
+        after do
+          WebMock.reset!
+        end
+
+        context "a single dependency with a site source" do
+
+          context "resolving" do
+            let(:repo_path) { tmp_path.join("repo/resolve") }
+            before do
+              repo_path.rmtree if repo_path.exist?
+              repo_path.mkpath
+              repo_path.join("cookbooks").mkpath
+              cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
+                #!/usr/bin/env ruby
+                cookbook "sample", :site => #{api_url.inspect}
+              CHEFFILE
+              repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
+            end
+
+            context "the resolve" do
+              it "should not raise an exception" do
+                expect { Action::Resolve.new(env).run }.to_not raise_error
+              end
+            end
+
+            context "the results" do
+              before { Action::Resolve.new(env).run }
+
+              it "should create the lockfile" do
+                repo_path.join("Cheffile.lock").should exist
+              end
+
+              it "should not attempt to install the cookbok" do
+                repo_path.join("cookbooks/sample").should_not exist
+              end
+            end
+          end
+
+          context "intalling" do
+            let(:repo_path) { tmp_path.join("repo/install") }
+            before do
+              repo_path.rmtree if repo_path.exist?
+              repo_path.mkpath
+              repo_path.join("cookbooks").mkpath
+              cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
+                #!/usr/bin/env ruby
+                cookbook "sample", :site => #{api_url.inspect}
+              CHEFFILE
+              repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
+
+              Action::Resolve.new(env).run
+            end
+
+            context "the install" do
+              it "should not raise an exception" do
+                expect { Action::Install.new(env).run }.to_not raise_error
+              end
+            end
+
+            context "the results" do
+              before { Action::Install.new(env).run }
+
+              it "should create the lockfile" do
+                repo_path.join("Cheffile.lock").should exist
+              end
+
+              it "should create a directory for the cookbook" do
+                repo_path.join("cookbooks/sample").should exist
+              end
+
+              it "should copy the cookbook files into the cookbook directory" do
+                repo_path.join("cookbooks/sample/metadata.rb").should exist
+              end
+            end
+          end
+
+          context "resolving and separately installing" do
+            let(:repo_path) { tmp_path.join("repo/resolve-install") }
+            before do
+              repo_path.rmtree if repo_path.exist?
+              repo_path.mkpath
+              repo_path.join("cookbooks").mkpath
+              cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
+                #!/usr/bin/env ruby
+                cookbook "sample", :site => #{api_url.inspect}
+              CHEFFILE
+              repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
+
+              Action::Resolve.new(env).run
+              repo_path.join("tmp").rmtree if repo_path.join("tmp").exist?
+            end
+
+            context "the install" do
+              it "should not raise an exception" do
+                expect { Action::Install.new(env).run }.to_not raise_error
+              end
+            end
+
+            context "the results" do
+              before { Action::Install.new(env).run }
+
+              it "should create a directory for the cookbook" do
+                repo_path.join("cookbooks/sample").should exist
+              end
+
+              it "should copy the cookbook files into the cookbook directory" do
+                repo_path.join("cookbooks/sample/metadata.rb").should exist
+              end
+            end
+          end
+
+        end
+
+        context "when the repo path has a space" do
+
+          let(:repo_path) { tmp_path.join("repo/with extra spaces/resolve") }
+
+          before do
+            repo_path.rmtree if repo_path.exist?
+            repo_path.mkpath
+            repo_path.join("cookbooks").mkpath
+
+            cheffile = Helpers.strip_heredoc(<<-CHEFFILE)
+              #!/usr/bin/env ruby
+              cookbook "sample", :site => #{api_url.inspect}
+            CHEFFILE
+            repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
+          end
+
+          after do
+            repo_path.rmtree
+          end
+
+          context "the resolution" do
+            it "should not raise an exception" do
+              expect { Action::Resolve.new(env).run }.to_not raise_error
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require "librarian/action/base"
+
+module Librarian
+  describe Action::Base do
+
+    let(:env) { mock }
+    let(:action) { described_class.new(env) }
+
+    subject { action }
+
+    it { should respond_to :environment }
+
+    it "should have the environment that was assigned to it" do
+      action.environment.should be env
+    end
+
+  end
+end

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

@@ -0,0 +1,102 @@
+require "librarian/action/clean"
+
+module Librarian
+  describe Action::Clean do
+
+    let(:env) { mock }
+    let(:action) { described_class.new(env) }
+
+    before do
+      action.stub(:debug)
+    end
+
+    describe "#run" do
+
+      describe "behavior" do
+
+        after do
+          action.run
+        end
+
+        describe "clearing the cache path" do
+
+          before do
+            action.stub(:clean_install_path)
+          end
+
+          context "when the cache path is missing" do
+            before do
+              env.stub_chain(:cache_path, :exist?) { false }
+            end
+
+            it "should not try to clear the cache path" do
+              env.cache_path.should_receive(:rmtree).never
+            end
+          end
+
+          context "when the cache path is present" do
+            before do
+              env.stub_chain(:cache_path, :exist?) { true }
+            end
+
+            it "should try to clear the cache path" do
+              env.cache_path.should_receive(:rmtree).exactly(:once)
+            end
+          end
+
+        end
+
+        describe "clearing the install path" do
+
+          before do
+            action.stub(:clean_cache_path)
+          end
+
+          context "when the install path is missing" do
+            before do
+              env.stub_chain(:install_path, :exist?) { false }
+            end
+
+            it "should not try to clear the install path" do
+              env.install_path.should_receive(:children).never
+            end
+          end
+
+          context "when the install path is present" do
+            before do
+              env.stub_chain(:install_path, :exist?) { true }
+            end
+
+            it "should try to clear the install path" do
+              children = [mock, mock, mock]
+              children.each do |child|
+                child.stub(:file?) { false }
+              end
+              env.stub_chain(:install_path, :children) { children }
+
+              children.each do |child|
+                child.should_receive(:rmtree).exactly(:once)
+              end
+            end
+
+            it "should only try to clear out directories from the install path, not files" do
+              children = [mock(:file? => false), mock(:file? => true), mock(:file? => true)]
+              env.stub_chain(:install_path, :children) { children }
+
+              children.select(&:file?).each do |child|
+                child.should_receive(:rmtree).never
+              end
+              children.reject(&:file?).each do |child|
+                child.should_receive(:rmtree).exactly(:once)
+              end
+            end
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

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