librarian 0.0.9 → 0.0.10

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

@@ -1,7 +1,11 @@
+require 'pathname'
+require 'json'
 require 'webmock'
 
 require 'librarian'
 require 'librarian/helpers'
+require 'librarian/action/resolve'
+require 'librarian/action/install'
 require 'librarian/chef'
 
 module Librarian
@@ -41,10 +45,13 @@ module Librarian
           }
         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) }
+          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
@@ -67,58 +74,109 @@ module Librarian
 
         context "a single dependency with a site source" do
 
-          it "should resolve" do
-            repo_path = tmp_path.join("repo/resolve")
-            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) }
-            Chef.stub!(:project_path) { repo_path }
-
-            Chef.resolve!
-            repo_path.join("Cheffile.lock").should exist
-            repo_path.join("cookbooks/sample").should_not exist
+          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
 
-          it "should install" do
-            repo_path = tmp_path.join("repo/install")
-            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) }
-            Chef.stub!(:project_path) { repo_path }
-
-            Chef.install!
-            repo_path.join("Cheffile.lock").should exist
-            repo_path.join("cookbooks/sample").should exist
-            repo_path.join("cookbooks/sample/metadata.rb").should exist
+          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
 
-          it "should resolve and separately install" do
-            repo_path = tmp_path.join("repo/resolve-install")
-            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) }
-            Chef.stub!(:project_path) { repo_path }
-
-            Chef.resolve!
-            repo_path.join("tmp").rmtree if repo_path.join("tmp").exist?
-            Chef.install!
-            repo_path.join("cookbooks/sample").should exist
-            repo_path.join("cookbooks/sample/metadata.rb").should exist
+          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
@@ -137,15 +195,16 @@ module Librarian
               cookbook "sample", :site => #{api_url.inspect}
             CHEFFILE
             repo_path.join("Cheffile").open("wb") { |f| f.write(cheffile) }
-            Chef.stub!(:project_path) { repo_path }
           end
 
           after do
             repo_path.rmtree
           end
 
-          it "should resolve" do
-            expect { Chef.resolve! }.to_not raise_error
+          context "the resolution" do
+            it "should not raise an exception" do
+              expect { Action::Resolve.new(env).run }.to_not raise_error
+            end
           end
 
         end

data/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/spec/unit/action/clean_spec.rb

@@ -0,0 +1,133 @@
+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)
+            action.stub(:clean_lockfile_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)
+            action.stub(:clean_lockfile_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
+
+        describe "clearing the lockfile path" do
+
+          before do
+            action.stub(:clean_cache_path)
+            action.stub(:clean_install_path)
+          end
+
+          context "when the lockfile path is missing" do
+            before do
+              env.stub_chain(:lockfile_path, :exist?) { false }
+            end
+
+            it "should not try to clear the lockfile path" do
+              env.lockfile_path.should_receive(:rmtree).never
+            end
+          end
+
+          context "when the lockfile path is present" do
+            before do
+              env.stub_chain(:lockfile_path, :exist?) { true }
+            end
+
+            it "should try to clear the lockfile path" do
+              env.lockfile_path.should_receive(:rmtree).exactly(:once)
+            end
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/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/spec/unit/action/install_spec.rb

@@ -0,0 +1,113 @@
+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
+
+          let(:manifests) { [mock, mock, mock] }
+          let(:sorted_manifests) { [mock, mock, mock, mock] }
+          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, cache, and install the manifests" do
+            ManifestSet.should_receive(:sort).with(manifests).exactly(:once).ordered { sorted_manifests }
+
+            sorted_manifests.each do |manifest|
+              source = mock
+              manifest.stub(:source) { source }
+              source.should_receive(:cache!).with([manifest]).exactly(:once).ordered
+            end
+
+            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 not try to create the install path if it already exists" do
+            action.stub(:sorted_manifests) { sorted_manifests }
+            action.stub(:cache_manifests)
+            action.stub(:install_manifests)
+
+            install_path.stub(:exist?) { true }
+            install_path.should_not_receive(:mkpath)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end