librarian-puppet-lmco 0.9.8.2

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

@@ -0,0 +1,217 @@
+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/integration/chef/source/site") }
+        after { tmp_path.rmtree if tmp_path && tmp_path.exist? }
+        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
+        let(:sample_0_6_5_package) do
+          s = StringIO.new
+          z = Zlib::GzipWriter.new(s, Zlib::NO_COMPRESSION)
+          t = Archive::Tar::Minitar::Output.new(z)
+          t.tar.add_file_simple("sample/metadata.rb", :mode => 0700,
+            :size => sample_metadata.bytesize){|io| io.write(sample_metadata)}
+          t.close
+          z.close unless z.closed?
+          s.string
+        end
+
+        # depends on repo_path being defined in each context
+        let(:env) { Environment.new(:project_path => repo_path) }
+
+        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_0_6_5_package)
+        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/support/cli_macro.rb

@@ -0,0 +1,114 @@
+require "json"
+require "pathname"
+require "securerandom"
+require "stringio"
+require "thor"
+
+require "librarian/helpers"
+
+module CliMacro
+
+  class FakeShell < Thor::Shell::Basic
+    def stdout
+      @stdout ||= StringIO.new
+    end
+    def stderr
+      @stderr ||= StringIO.new
+    end
+    def stdin
+      raise "unsupported"
+    end
+  end
+
+  class FileMatcher
+    attr_accessor :rel_path, :content, :type, :base_path
+    def initialize(rel_path, content, options = { })
+      self.rel_path = rel_path
+      self.content = content
+      self.type = options[:type]
+    end
+    def full_path
+      @full_path ||= base_path + rel_path
+    end
+    def actual_content
+      @actual_content ||= begin
+        s = full_path.read
+        s = JSON.parse(s) if type == :json
+        s
+      end
+    end
+    def matches?(base_path)
+      base_path = Pathname(base_path) unless Pathname === base_path
+      self.base_path = base_path
+
+      full_path.file? && (!content || actual_content == content)
+    end
+  end
+
+  def self.included(base)
+    base.instance_exec do
+      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) { project_path.join("tmp/spec/cli") }
+      let(:pwd) { tmp + SecureRandom.hex(8) }
+
+      before { tmp.mkpath }
+      before { pwd.mkpath }
+
+      after  { tmp.rmtree }
+    end
+  end
+
+  def cli!(*args)
+    @shell = FakeShell.new
+    @exit_status = Dir.chdir(pwd) do
+      described_class.with_environment do
+        described_class.returning_status do
+          described_class.start args, :shell => @shell
+        end
+      end
+    end
+  end
+
+  def write_file!(path, content)
+    path = pwd.join(path)
+    path.dirname.mkpath
+    path.open("wb"){|f| f.write(content)}
+  end
+
+  def write_json_file!(path, content)
+    write_file! path, JSON.dump(content)
+  end
+
+  def strip_heredoc(text)
+    Librarian::Helpers.strip_heredoc(text)
+  end
+
+  def shell
+    @shell
+  end
+
+  def stdout
+    shell.stdout.string
+  end
+
+  def stderr
+    shell.stderr.string
+  end
+
+  def exit_status
+    @exit_status
+  end
+
+  def have_file(rel_path, content = nil)
+    FileMatcher.new(rel_path, content)
+  end
+
+  def have_json_file(rel_path, content)
+    FileMatcher.new(rel_path, content, :type => :json)
+  end
+
+end

data/vendor/librarian/spec/support/method_patch_macro.rb

@@ -0,0 +1,30 @@
+require "securerandom"
+
+module MethodPatchMacro
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def with_module_method(mod, meth, &block)
+      tag = SecureRandom.hex(8)
+      orig_meth = "_#{tag}_#{meth}".to_sym
+      around do |example|
+        mod.module_eval do
+          alias_method orig_meth, meth
+          define_method meth, &block
+        end
+        begin
+          example.run
+        ensure
+          mod.module_eval do
+            alias_method meth, orig_meth
+            remove_method orig_meth
+          end
+        end
+      end
+    end
+  end
+
+end

data/vendor/librarian/spec/support/with_env_macro.rb

@@ -0,0 +1,20 @@
+module WithEnvMacro
+
+  module ClassMethods
+
+    def with_env(new)
+      old = Hash[new.map{|k, v| [k, ENV[k]]}]
+
+      before { ENV.update(new) }
+      after  { ENV.update(old) }
+    end
+
+  end
+
+  private
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  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