berkshelf 0.1.1

data/spec/fixtures/lockfile_spec/with_lock/Berksfile

@@ -0,0 +1 @@
+cookbook 'nginx', '= 0.101.0'

data/spec/fixtures/lockfile_spec/without_lock/Berksfile.lock

@@ -0,0 +1,5 @@
+cookbook 'nginx', :locked_version => '0.101.0'
+cookbook 'build-essential', :locked_version => '1.0.2'
+cookbook 'runit', :locked_version => '0.15.0'
+cookbook 'bluepill', :locked_version => '1.0.4'
+cookbook 'ohai', :locked_version => '1.0.2'

data/spec/spec_helper.rb

@@ -0,0 +1,92 @@
+require 'rubygems'
+require 'bundler'
+require 'spork'
+require 'vcr'
+
+Spork.prefork do
+  require 'rspec'
+  require 'simplecov'
+  require 'pp'
+  require 'json_spec'
+  require 'webmock/rspec'
+  
+  APP_ROOT = File.expand_path('../../', __FILE__)
+  
+  Dir[File.join(APP_ROOT, "spec/support/**/*.rb")].each {|f| require f}
+
+  VCR.configure do |c|
+    c.cassette_library_dir = File.join(File.dirname(__FILE__), 'fixtures', 'vcr_cassettes')
+    c.hook_into :webmock
+  end
+
+  RSpec.configure do |config|
+    config.include Berkshelf::RSpec::FileSystemMatchers
+    config.include JsonSpec::Helpers
+    
+    config.mock_with :rspec
+    config.treat_symbols_as_metadata_keys_with_true_values = true
+    config.filter_run :focus => true
+    config.run_all_when_everything_filtered = true
+
+    config.around do |example|
+      # Dynamically create cassettes based on the name of the example
+      # being run. This creates a new cassette for every test.
+      cur = example.metadata
+      identifiers = [example.metadata[:description_args]]
+      while cur = cur[:example_group] do
+        identifiers << cur[:description_args]
+      end
+
+      VCR.use_cassette(identifiers.reverse.join(' ')) do
+        example.run
+      end
+    end
+
+    config.before(:each) do
+      clean_tmp_path
+      Berkshelf.cookbook_store = Berkshelf::CookbookStore.new(tmp_path.join("downloader_tmp"))
+    end
+  end
+
+  SimpleCov.start do
+    add_filter 'spec/'
+  end
+
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+
+  def example_cookbook_from_path
+    @example_cookbook_from_path ||= Berkshelf::Cookbook.new('example_cookbook', path: File.join(File.dirname(__FILE__), 'fixtures', 'cookbooks'))
+  end
+
+  def app_root_path
+    Pathname.new(APP_ROOT)
+  end
+
+  def tmp_path
+    app_root_path.join('spec/tmp')
+  end
+
+  def fixtures_path
+    app_root_path.join('spec/fixtures')
+  end
+
+  def clean_tmp_path
+    FileUtils.rm_rf(tmp_path)
+    FileUtils.mkdir_p(tmp_path)
+  end
+end
+
+Spork.each_run do
+  require 'berkshelf'
+end

data/spec/support/chef_api.rb

@@ -0,0 +1,27 @@
+require 'chef/rest'
+require 'chef/cookbook_version'
+
+module Berkshelf
+  module RSpec
+    module ChefAPI
+      def purge_cookbook(name, version)
+        rest.delete_rest("cookbooks/#{name}/#{version}?purge=true")
+      rescue Net::HTTPServerException => e
+        raise unless e.to_s =~ /^404/
+      end
+
+      def server_has_cookbook?(name, version)
+        rest.get_rest("cookbooks/#{name}/#{version}")
+        true
+      rescue Net::HTTPServerException => e
+        false
+      end
+
+      private
+
+        def rest
+          quietly { Chef::REST.new(Chef::Config[:chef_server_url]) }
+        end
+    end
+  end
+end

data/spec/support/matchers/file_system_matchers.rb

@@ -0,0 +1,115 @@
+# Taken from (https://github.com/carlhuda/beard)
+# Permission granted by Yehuda Katz (Jan 4th, 2012)
+module Berkshelf
+  module RSpec
+    module FileSystemMatchers
+      class File
+        def initialize(name, &block)
+          @contents = []
+          @name = name
+
+          if block_given?
+            instance_eval(&block)
+          end
+        end
+
+        def contains(text)
+          @contents << text
+        end
+
+        def matches?(root)
+          unless root.join(@name).exist?
+            throw :failure, root.join(@name)
+          end
+
+          contents = ::File.read(root.join(@name))
+
+          @contents.each do |string|
+            unless contents.include?(string)
+              throw :failure, [root.join(@name), string, contents]
+            end
+          end
+        end
+      end
+
+      class Directory
+        attr_reader :tree
+
+        def initialize(root = nil, &block)
+          @tree = {}
+          @negative_tree = []
+          @root = root
+          instance_eval(&block) if block_given?
+        end
+
+        def directory(name, &block)
+          @tree[name] = block_given? && Directory.new(location(name), &block)
+        end
+
+        def file(name, &block)
+          @tree[name] = File.new(location(name), &block)
+        end
+
+        def no_file(name)
+          @negative_tree << name
+        end
+
+        def location(name)
+          [@root, name].compact.join("/")
+        end
+
+        def matches?(root)
+          @tree.each do |file, value|
+            unless value
+              unless root.join(location(file)).exist?
+                throw :failure, "#{root}/#{location(file)}"
+              end
+            else
+              value.matches?(root)
+            end
+          end
+
+          @negative_tree.each do |file|
+            if root.join(location(file)).exist?
+              throw :failure, [:not, "unexpected #{root}/#{location(file)}"]
+            end
+          end
+
+          nil
+        end
+      end
+
+      class Root < Directory
+        def failure_message
+          if @failure.is_a?(Array) && @failure[0] == :not
+            "Structure should not have had #{@failure[1]}, but it did"
+          elsif @failure.is_a?(Array)
+            "Structure should have #{@failure[0]} with #{@failure[1]}. It had:\n#{@failure[2]}"
+          else
+            "Structure should have #{@failure}, but it didn't"
+          end
+        end
+
+        def negative_failure_message
+          if @failure.is_a?(Array) && @failure[0] == :not
+            "Structure had #{@failure}, but it shouldn't have"
+          else
+            "Structure had #{@failure}, but it shouldn't have"
+          end
+        end
+
+        def matches?(root)
+          @failure = catch :failure do
+            super
+          end
+
+          !@failure
+        end
+      end
+
+      def have_structure(&block)
+        Root.new(&block)
+      end
+    end
+  end
+end

data/spec/support/matchers/filepath_matchers.rb

@@ -0,0 +1,19 @@
+require 'pathname'
+
+RSpec::Matchers.define :be_relative_path do
+  match do |given|
+    if given.nil?
+      false
+    else
+      Pathname.new(given).relative?
+    end
+  end
+
+  failure_message_for_should do |given|
+    "Expected '#{given}' to be a relative path but got an absolute path."
+  end
+
+  failure_message_for_should_not do |given|
+    "Expected '#{given}' to not be a relative path but got an absolute path."
+  end
+end

data/spec/unit/berkshelf/cached_cookbook_spec.rb

@@ -0,0 +1,420 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe CachedCookbook do
+    describe "ClassMethods" do
+      subject { CachedCookbook }
+
+      describe "#from_path" do
+        before(:each) do
+          @cached_cb = subject.from_path(fixtures_path.join("cookbooks", "example_cookbook-0.5.0"))
+        end
+
+        it "returns an instance of CachedCookbook" do
+          @cached_cb.should be_a(CachedCookbook)
+        end
+
+        it "sets a version number" do
+          @cached_cb.version.should eql("0.5.0")
+        end
+
+        context "given a path that does not contain a cookbook" do
+          it "returns nil" do
+            subject.from_path(tmp_path).should be_nil
+          end
+        end
+
+        context "given a path that does not match the CachedCookbook dirname format" do
+          it "returns nil" do
+            subject.from_path(fixtures_path.join("cookbooks", "example_cookbook")).should be_nil
+          end
+        end
+      end
+
+      describe "#checksum" do
+        it "returns a checksum of the given filepath" do
+          subject.checksum(fixtures_path.join("cookbooks", "example_cookbook-0.5.0", "README.md")).should eql("6e21094b7a920e374e7261f50e9c4eef")
+        end
+
+        context "given path does not exist" do
+          it "raises an Errno::ENOENT error" do
+            lambda {
+              subject.checksum(fixtures_path.join("notexisting.file"))
+            }.should raise_error(Errno::ENOENT)
+          end
+        end
+      end
+    end
+
+    let(:cb_path) { fixtures_path.join("cookbooks", "nginx-0.100.5") }
+    subject { CachedCookbook.from_path(cb_path) }
+
+    describe "#checksums" do
+      it "returns a Hash containing an entry for all matching cookbook files on disk" do
+        subject.checksums.should have(11).items
+      end
+
+      it "has a checksum for each key" do
+        subject.checksums.should have_key("fb1f925dcd5fc4ebf682c4442a21c619")
+      end
+
+      it "has a filepath for each value" do
+        subject.checksums.should have_value(cb_path.join("recipes/default.rb").to_s)
+      end
+    end
+
+    describe "#manifest" do
+      it "returns a Mash with a key for each cookbook file category" do
+        [
+          :recipes,
+          :definitions,
+          :libraries,
+          :attributes,
+          :files,
+          :templates,
+          :resources,
+          :providers,
+          :root_files
+        ].each do |category|
+          subject.manifest.should have_key(category)
+        end
+      end
+    end
+
+    describe "#validate!" do
+      it "returns true if the cookbook of the given name and version is valid" do
+        @cb = CachedCookbook.from_path(fixtures_path.join("cookbooks", "example_cookbook-0.5.0"))
+
+        @cb.validate!.should be_true
+      end
+
+      it "raises CookbookSyntaxError if the cookbook contains invalid ruby files" do
+        @cb = CachedCookbook.from_path(fixtures_path.join("cookbooks", "invalid_ruby_files-1.0.0"))
+
+        lambda {
+          @cb.validate!
+        }.should raise_error(CookbookSyntaxError)
+      end
+
+      it "raises CookbookSyntaxError if the cookbook contains invalid template files" do
+        @cb = CachedCookbook.from_path(fixtures_path.join("cookbooks", "invalid_template_files-1.0.0"))
+
+        lambda {
+          @cb.validate!
+        }.should raise_error(CookbookSyntaxError)
+      end
+    end
+
+    describe "#file_metadata" do
+      let(:file) { subject.path.join("files", "default", "mime.types") }
+
+      before(:each) { @metadata = subject.file_metadata(:file, file) }
+
+      it "has a 'path' key whose value is a relative path from the CachedCookbook's path" do
+        @metadata.should have_key(:path)
+        @metadata[:path].should be_relative_path
+        @metadata[:path].should eql("files/default/mime.types")
+      end
+
+      it "has a 'name' key whose value is the basename of the target file" do
+        @metadata.should have_key(:name)
+        @metadata[:name].should eql("mime.types")
+      end
+
+      it "has a 'checksum' key whose value is the checksum of the target file" do
+        @metadata.should have_key(:checksum)
+        @metadata[:checksum].should eql("06e7eca1d6cb608e2e74fd1f8e059f34")
+      end
+
+      it "has a 'specificity' key" do
+        @metadata.should have_key(:specificity)
+      end
+
+      context "given a 'template' or 'file' berksfile type" do
+        let(:file) { subject.path.join("files", "ubuntu", "mime.types") }
+        before(:each) { @metadata = subject.file_metadata(:files, file) }
+
+        it "has a 'specificity' key whose value represents the specificity found in filepath" do
+          @metadata[:specificity].should eql("ubuntu")
+        end
+      end
+
+      context "given any berksfile type that is not a 'template' or 'file'" do
+        let(:file) { subject.path.join("README.md") }
+        before(:each) { @metadata = subject.file_metadata(:root, file) }
+
+        it "has a 'specificity' key whose value is 'default'" do
+          @metadata[:specificity].should eql("default")
+        end
+      end
+    end
+
+    describe "#to_hash" do
+      before(:each) do
+        @hash = subject.to_hash
+      end
+
+      let(:cookbook_name) { subject.cookbook_name }
+      let(:cookbook_version) { subject.version }
+
+      it "has a 'recipes' key with a value of an Array Hashes" do
+        @hash.should have_key('recipes')
+        @hash['recipes'].should be_a(Array)
+        @hash['recipes'].each do |item|
+          item.should be_a(Hash)
+        end
+      end
+
+      it "has a 'name' key value pair in a Hash of the 'recipes' Array of Hashes" do
+        @hash['recipes'].first.should have_key('name')
+      end
+
+      it "has a 'path' key value pair in a Hash of the 'recipes' Array of Hashes" do
+        @hash['recipes'].first.should have_key('path')
+      end
+
+      it "has a 'checksum' key value pair in a Hash of the 'recipes' Array of Hashes" do
+        @hash['recipes'].first.should have_key('checksum')
+      end
+
+      it "has a 'specificity' key value pair in a Hash of the 'recipes' Array of Hashes" do
+        @hash['recipes'].first.should have_key('specificity')
+      end
+
+      it "has a 'definitions' key with a value of an Array Hashes" do
+        @hash.should have_key('definitions')
+        @hash['definitions'].should be_a(Array)
+        @hash['definitions'].each do |item|
+          item.should be_a(Hash)
+        end
+      end
+
+      it "has a 'name' key value pair in a Hash of the 'definitions' Array of Hashes" do
+        @hash['definitions'].first.should have_key('name')
+      end
+
+      it "has a 'path' key value pair in a Hash of the 'definitions' Array of Hashes" do
+        @hash['definitions'].first.should have_key('path')
+      end
+
+      it "has a 'checksum' key value pair in a Hash of the 'definitions' Array of Hashes" do
+        @hash['definitions'].first.should have_key('checksum')
+      end
+
+      it "has a 'specificity' key value pair in a Hash of the 'definitions' Array of Hashes" do
+        @hash['definitions'].first.should have_key('specificity')
+      end
+
+      it "has a 'libraries' key with a value of an Array Hashes" do
+        @hash.should have_key('libraries')
+        @hash['libraries'].should be_a(Array)
+        @hash['libraries'].each do |item|
+          item.should be_a(Hash)
+        end
+      end
+
+      it "has a 'name' key value pair in a Hash of the 'libraries' Array of Hashes" do
+        @hash['libraries'].first.should have_key('name')
+      end
+
+      it "has a 'path' key value pair in a Hash of the 'libraries' Array of Hashes" do
+        @hash['libraries'].first.should have_key('path')
+      end
+
+      it "has a 'checksum' key value pair in a Hash of the 'libraries' Array of Hashes" do
+        @hash['libraries'].first.should have_key('checksum')
+      end
+
+      it "has a 'specificity' key value pair in a Hash of the 'libraries' Array of Hashes" do
+        @hash['libraries'].first.should have_key('specificity')
+      end
+
+      it "has a 'attributes' key with a value of an Array Hashes" do
+        @hash.should have_key('attributes')
+        @hash['attributes'].should be_a(Array)
+        @hash['attributes'].each do |item|
+          item.should be_a(Hash)
+        end
+      end
+
+      it "has a 'name' key value pair in a Hash of the 'attributes' Array of Hashes" do
+        @hash['attributes'].first.should have_key('name')
+      end
+
+      it "has a 'path' key value pair in a Hash of the 'attributes' Array of Hashes" do
+        @hash['attributes'].first.should have_key('path')
+      end
+
+      it "has a 'checksum' key value pair in a Hash of the 'attributes' Array of Hashes" do
+        @hash['attributes'].first.should have_key('checksum')
+      end
+
+      it "has a 'specificity' key value pair in a Hash of the 'attributes' Array of Hashes" do
+        @hash['attributes'].first.should have_key('specificity')
+      end
+
+      it "has a 'files' key with a value of an Array Hashes" do
+        @hash.should have_key('files')
+        @hash['files'].should be_a(Array)
+        @hash['files'].each do |item|
+          item.should be_a(Hash)
+        end
+      end
+
+      it "has a 'name' key value pair in a Hash of the 'files' Array of Hashes" do
+        @hash['files'].first.should have_key('name')
+      end
+
+      it "has a 'path' key value pair in a Hash of the 'files' Array of Hashes" do
+        @hash['files'].first.should have_key('path')
+      end
+
+      it "has a 'checksum' key value pair in a Hash of the 'files' Array of Hashes" do
+        @hash['files'].first.should have_key('checksum')
+      end
+
+      it "has a 'specificity' key value pair in a Hash of the 'files' Array of Hashes" do
+        @hash['files'].first.should have_key('specificity')
+      end
+
+      it "has a 'templates' key with a value of an Array Hashes" do
+        @hash.should have_key('templates')
+        @hash['templates'].should be_a(Array)
+        @hash['templates'].each do |item|
+          item.should be_a(Hash)
+        end
+      end
+
+      it "has a 'name' key value pair in a Hash of the 'templates' Array of Hashes" do
+        @hash['templates'].first.should have_key('name')
+      end
+
+      it "has a 'path' key value pair in a Hash of the 'templates' Array of Hashes" do
+        @hash['templates'].first.should have_key('path')
+      end
+
+      it "has a 'checksum' key value pair in a Hash of the 'templates' Array of Hashes" do
+        @hash['templates'].first.should have_key('checksum')
+      end
+
+      it "has a 'specificity' key value pair in a Hash of the 'templates' Array of Hashes" do
+        @hash['templates'].first.should have_key('specificity')
+      end
+
+      it "has a 'resources' key with a value of an Array Hashes" do
+        @hash.should have_key('resources')
+        @hash['resources'].should be_a(Array)
+        @hash['resources'].each do |item|
+          item.should be_a(Hash)
+        end
+      end
+
+      it "has a 'name' key value pair in a Hash of the 'resources' Array of Hashes" do
+        @hash['resources'].first.should have_key('name')
+      end
+
+      it "has a 'path' key value pair in a Hash of the 'resources' Array of Hashes" do
+        @hash['resources'].first.should have_key('path')
+      end
+
+      it "has a 'checksum' key value pair in a Hash of the 'resources' Array of Hashes" do
+        @hash['resources'].first.should have_key('checksum')
+      end
+
+      it "has a 'specificity' key value pair in a Hash of the 'resources' Array of Hashes" do
+        @hash['resources'].first.should have_key('specificity')
+      end
+
+      it "has a 'providers' key with a value of an Array Hashes" do
+        @hash.should have_key('providers')
+        @hash['providers'].should be_a(Array)
+        @hash['providers'].each do |item|
+          item.should be_a(Hash)
+        end
+      end
+
+      it "has a 'name' key value pair in a Hash of the 'providers' Array of Hashes" do
+        @hash['providers'].first.should have_key('name')
+      end
+
+      it "has a 'path' key value pair in a Hash of the 'providers' Array of Hashes" do
+        @hash['providers'].first.should have_key('path')
+      end
+
+      it "has a 'checksum' key value pair in a Hash of the 'providers' Array of Hashes" do
+        @hash['providers'].first.should have_key('checksum')
+      end
+
+      it "has a 'specificity' key value pair in a Hash of the 'providers' Array of Hashes" do
+        @hash['providers'].first.should have_key('specificity')
+      end
+
+      it "has a 'root_files' key with a value of an Array Hashes" do
+        @hash.should have_key('root_files')
+        @hash['root_files'].should be_a(Array)
+        @hash['root_files'].each do |item|
+          item.should be_a(Hash)
+        end
+      end
+
+      it "has a 'name' key value pair in a Hash of the 'root_files' Array of Hashes" do
+        @hash['root_files'].first.should have_key('name')
+      end
+
+      it "has a 'path' key value pair in a Hash of the 'root_files' Array of Hashes" do
+        @hash['root_files'].first.should have_key('path')
+      end
+
+      it "has a 'checksum' key value pair in a Hash of the 'root_files' Array of Hashes" do
+        @hash['root_files'].first.should have_key('checksum')
+      end
+
+      it "has a 'specificity' key value pair in a Hash of the 'root_files' Array of Hashes" do
+        @hash['root_files'].first.should have_key('specificity')
+      end
+
+      it "has a 'cookbook_name' key with a String value" do
+        @hash.should have_key('cookbook_name')
+        @hash['cookbook_name'].should be_a(String)
+      end
+
+      it "has a 'metadata' key with a Cookbook::Metadata value" do
+        @hash.should have_key('metadata')
+        @hash['metadata'].should be_a(Chef::Cookbook::Metadata)
+      end
+
+      it "has a 'version' key with a String value" do
+        @hash.should have_key('version')
+        @hash['version'].should be_a(String)
+      end
+
+      it "has a 'name' key with a String value" do
+        @hash.should have_key('name')
+        @hash['name'].should be_a(String)
+      end
+
+      it "has a value containing the cookbook name and version separated by a dash for 'name'" do
+        name, version = @hash['name'].split('-')
+
+        name.should eql(cookbook_name)
+        version.should eql(cookbook_version)
+      end
+
+      it "has a 'chef_type' key with 'cookbook_version' as the value" do
+        @hash.should have_key('chef_type')
+        @hash['chef_type'].should eql("cookbook_version")
+      end
+    end
+
+    describe "#to_json" do
+      before(:each) do
+        @json = subject.to_json
+      end
+
+      it "has a 'json_class' key with 'Chef::CookbookVersion' as the value" do
+        @json.should have_json_path('json_class')
+        parse_json(@json)['json_class'].should eql("Chef::CookbookVersion")
+      end
+    end
+  end
+end