librarian-puppet-maestrodev 0.9.7

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/functional/source/git/repository_spec.rb

@@ -0,0 +1,149 @@
+require "fileutils"
+require "pathname"
+require "securerandom"
+
+require "librarian/source/git/repository"
+
+describe Librarian::Source::Git::Repository do
+
+  let(:env) do
+    double(:ui => nil, :logger => double(:debug => nil, :info => nil))
+  end
+
+  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 + "tmp/spec/unit/source/git/repository-spec" }
+  let(:git_source_path) { tmp_path + SecureRandom.hex(16) }
+  let(:branch) { "the-branch" }
+  let(:tag) { "the-tag" }
+  let(:atag) { "the-atag" }
+
+  before do
+    git_source_path.mkpath
+    Dir.chdir(git_source_path) do
+      `git init`
+
+      # master
+      `touch butter.txt`
+      `git add butter.txt`
+      `git commit -m "Initial Commit"`
+
+      # branch
+      `git checkout -b #{branch} --quiet`
+      `touch jam.txt`
+      `git add jam.txt`
+      `git commit -m "Branch Commit"`
+      `git checkout master --quiet`
+
+      # tag
+      `git checkout -b deletable --quiet`
+      `touch jelly.txt`
+      `git add jelly.txt`
+      `git commit -m "Tag Commit"`
+      `git tag #{tag}`
+      `git checkout master --quiet`
+      `git branch -D deletable`
+
+      # annotated tag
+      `git checkout -b deletable --quiet`
+      `touch jelly.txt`
+      `git add jelly.txt`
+      `git commit -m "Tag Commit"`
+      `git tag -am "Annotated Tag Commit" #{atag}`
+      `git checkout master --quiet`
+      `git branch -D deletable`
+    end
+  end
+
+  context "the original" do
+    subject { described_class.new(env, git_source_path) }
+
+    it "should recognize it" do
+      subject.should be_git
+    end
+
+    it "should not list any remotes for it" do
+      subject.remote_names.should be_empty
+    end
+
+    it "should not list any remote branches for it" do
+      subject.remote_branch_names.should be_empty
+    end
+  end
+
+  context "a clone" do
+    let(:git_clone_path) { tmp_path + SecureRandom.hex(16) }
+    subject { described_class.clone!(env, git_clone_path, git_source_path) }
+
+    let(:master_sha) { subject.hash_from("origin", "master") }
+    let(:branch_sha) { subject.hash_from("origin", branch) }
+    let(:tag_sha) { subject.hash_from("origin", tag) }
+    let(:atag_sha) { subject.hash_from("origin", atag) }
+
+    it "should recognize it" do
+      subject.should be_git
+    end
+
+    it "should have a single remote for it" do
+      subject.should have(1).remote_names
+    end
+
+    it "should have a remote with the expected name" do
+      subject.remote_names.first.should == "origin"
+    end
+
+    it "should have the remote branch" do
+      subject.remote_branch_names["origin"].should include branch
+    end
+
+    it "should be checked out on the master" do
+      subject.should be_checked_out(master_sha)
+    end
+
+    context "checking out the branch" do
+      before do
+        subject.checkout! branch
+      end
+
+      it "should be checked out on the branch" do
+        subject.should be_checked_out(branch_sha)
+      end
+
+      it "should not be checked out on the master" do
+        subject.should_not be_checked_out(master_sha)
+      end
+    end
+
+    context "checking out the tag" do
+      before do
+        subject.checkout! tag
+      end
+
+      it "should be checked out on the tag" do
+        subject.should be_checked_out(tag_sha)
+      end
+
+      it "should not be checked out on the master" do
+        subject.should_not be_checked_out(master_sha)
+      end
+    end
+
+    context "checking out the annotated tag" do
+      before do
+        subject.checkout! atag
+      end
+
+      it "should be checked out on the annotated tag" do
+        subject.should be_checked_out(atag_sha)
+      end
+
+      it "should not be checked out on the master" do
+        subject.should_not be_checked_out(master_sha)
+      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