librarian-puppet-maestrodev 0.9.7.5 → 0.9.8.1

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

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

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

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

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