berkshelf 3.0.0.beta7 → 3.0.0.beta8

data/lib/berkshelf/mixin.rb

@@ -1,7 +0,0 @@
-module Berkshelf
-  module Mixin; end
-end
-
-Dir["#{File.dirname(__FILE__)}/mixin/*.rb"].sort.each do |path|
-  require_relative "mixin/#{File.basename(path, '.rb')}"
-end

data/spec/support/mercurial.rb

@@ -1,123 +0,0 @@
-module Berkshelf
-  module RSpec
-    module Mercurial
-      require 'buff/shell_out'
-      include Buff::ShellOut
-
-      require_relative 'path_helpers'
-      include Berkshelf::RSpec::PathHelpers
-
-      def mercurial_origin_for(repo, options = {})
-        File.join("file://localhost", generate_fake_mercurial_remote(repo, options))
-      end
-
-      def generate_fake_mercurial_remote(uri, options = {})
-        repo_path = remotes.join(uri)
-
-        FileUtils.mkdir repo_path
-
-        Dir.chdir(repo_path) do
-          ENV['HGUSER'] = 'test_user'
-          shell_out "hg init"
-          shell_out "echo \"# a change!\" >> content_file"
-          if options[:is_cookbook]
-            shell_out "echo \"#cookbook\" >> metadata.rb"
-          end
-          shell_out "hg add ."
-          shell_out "hg commit -m \"A commit.\""
-          options[:tags].each do |tag|
-            shell_out "echo \"#{tag}\" > content_file"
-            shell_out "hg commit -m \"#{tag} content\""
-            shell_out "hg tag \"#{tag}\""
-          end if options.has_key? :tags
-          options[:branches].each do |branch|
-            shell_out "hg branch #{branch}"
-            shell_out "echo \"#{branch}\" > content_file"
-            shell_out "hg commit -m \"#{branch} content\""
-            shell_out "hg up default"
-          end if options.has_key? :branches
-        end
-        repo_path.to_path
-      end
-
-      # Calculate the id for the given mercurial rev.
-      #
-      # @param [#to_s] repo
-      #   the repository to show the rev for
-      # @param [#to_s] rev
-      #   the revision to identify
-      #
-      # @return [String]
-      def id_for_rev(repo, rev)
-        Dir.chdir remote_path(repo) do
-          shell_out("hg id -r '#{rev}'").stdout.split(' ').first.strip
-        end
-      end
-
-      # The clone path the given repo.
-      #
-      # @param [#to_s] repo
-      #   the name of the local repo
-      #
-      # @return [Pathname]
-      #   the path to the clone
-      def clone_path(repo)
-        clones.join(repo.to_s)
-      end
-
-      # The clone path the remote repo.
-      #
-      # @param [#to_s] repo
-      #   the name of the remote repo
-      #
-      # @return [Pathname]
-      #   the path to the clone
-      def remote_path(repo)
-        remotes.join(repo.to_s)
-      end
-
-      private
-
-        # The path to store the local git clones.
-        #
-        # @return [Pathname]
-        def clones
-          ensure_and_return(tmp_path.join('clones'))
-        end
-
-        # The path to store the git remotes.
-        #
-        # @return [Pathname]
-        def remotes
-          ensure_and_return(tmp_path.join('remotes'))
-        end
-
-        # Generate a cookbook by the given name.
-        #
-        # @param [#to_s] name
-        #   the name of the cookbook to create
-        # @param [Hash] options
-        #   the list ooptions to pass to the generator
-        def generate_mercurial_cookbook(name, options = {})
-          options = {
-              skip_vagrant: true,
-              skip_test_kitchen: true,
-              force: true,
-          }.merge(options)
-
-          Berkshelf::Cli.new.invoke(:cookbook, [name.to_s], options)
-        end
-
-        # Make sure the given path exists and return the path
-        #
-        # @param [#to_s] path
-        #   the path to create and return
-        #
-        # @return [Pathname]
-        def ensure_and_return(path)
-          FileUtils.mkdir(path) unless File.exist?(path)
-          return Pathname.new(path).expand_path
-        end
-    end
-  end
-end

data/spec/unit/berkshelf/formatters_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-
-describe Berkshelf::Formatters do
-  before do
-    @original = Berkshelf::Formatters.class_variable_get :@@formatters
-    Berkshelf::Formatters.class_variable_set :@@formatters, {}
-  end
-
-  after do
-    Berkshelf::Formatters.class_variable_set :@@formatters, @original
-  end
-
-  let(:format_id) { :rspec }
-  let(:format_klass) { Class.new { include Berkshelf::Formatters::AbstractFormatter } }
-
-  describe '::register' do
-    it 'adds the class of the includer to the list of registered formatters with the id' do
-      Berkshelf::Formatters.register(format_id, format_klass)
-
-      expect(Berkshelf::Formatters.formatters).to have_key(format_id)
-      expect(Berkshelf::Formatters.formatters[format_id]).to eq(format_klass)
-    end
-
-    context 'when given a string instead of a symbol as the ID' do
-      it 'converts the string to a symbol and registers it' do
-        Berkshelf::Formatters.register('rspec', format_klass)
-
-        expect(Berkshelf::Formatters.formatters).to have_key(:rspec)
-        expect(Berkshelf::Formatters.formatters[:rspec]).to eq(format_klass)
-      end
-    end
-
-    context 'when a formatter of the given ID has already been registered' do
-      it 'raises an InternalError' do
-        Berkshelf::Formatters.register(format_id, format_klass)
-
-        expect {
-          Berkshelf::Formatters.register(format_id, format_klass)
-        }.to raise_error(Berkshelf::InternalError)
-      end
-    end
-  end
-
-  describe '::formatters' do
-    before do
-      Berkshelf::Formatters.register(format_id, format_klass)
-    end
-
-    it "returns a hash where formatter ID's are keys and values are formatter classes" do
-      expect(Berkshelf::Formatters.formatters).to be_a(Hash)
-      expect(Berkshelf::Formatters.formatters).to have(1).item
-      expect(Berkshelf::Formatters.formatters.keys.first).to eq(format_id)
-      expect(Berkshelf::Formatters.formatters.values.first).to eq(format_klass)
-    end
-  end
-
-  describe '::get' do
-    before { Berkshelf::Formatters.register(format_id, format_klass) }
-
-    it 'returns the class constant of the given formatter ID' do
-      expect(Berkshelf::Formatters[format_id]).to eq(format_klass)
-    end
-
-    context 'when the ID has not been registered' do
-      it 'returns nil' do
-        expect(Berkshelf::Formatters[:not_there]).to be_nil
-      end
-    end
-  end
-
-  describe Berkshelf::Formatters::AbstractFormatter do
-    describe '::register_formatter' do
-      it 'delegates to Formatters' do
-        Berkshelf::Formatters.should_receive(:register).with(:rspec, format_klass)
-
-        format_klass.register_formatter(:rspec)
-      end
-    end
-
-    subject do
-      Class.new { include Berkshelf::Formatters::AbstractFormatter }.new
-    end
-
-    it 'has abstract methods for all the messaging modes' do
-      expect {
-        subject.install('my_coobook','1.2.3','http://community')
-      }.to raise_error(Berkshelf::AbstractFunction)
-
-      expect {
-        subject.use('my_coobook','1.2.3')
-      }.to raise_error(Berkshelf::AbstractFunction)
-
-      expect {
-        subject.use('my_coobook','1.2.3','http://community')
-      }.to raise_error(Berkshelf::AbstractFunction)
-
-      expect {
-        subject.upload('my_coobook','1.2.3','http://chef_server')
-      }.to raise_error(Berkshelf::AbstractFunction)
-
-      expect {
-        subject.msg('something you to know')
-      }.to raise_error(Berkshelf::AbstractFunction)
-
-      expect {
-        subject.error('whoa this is bad')
-      }.to raise_error(Berkshelf::AbstractFunction)
-
-      expect {
-        subject.fetch(double('dependency'))
-      }.to raise_error(Berkshelf::AbstractFunction)
-    end
-  end
-end

data/spec/unit/berkshelf/git_spec.rb

@@ -1,312 +0,0 @@
-require 'spec_helper'
-
-describe Berkshelf::Git do
-  let(:git) { Berkshelf::Git }
-
-  describe '::find_git' do
-    it 'finds git' do
-      expect(Berkshelf::Git.find_git).to_not be_nil
-    end
-
-    it 'raises an error if git cannot be not found' do
-      ENV.should_receive(:[]).with('PATH').and_return(String.new)
-
-      expect {
-        Berkshelf::Git.find_git
-      }.to raise_error(Berkshelf::GitNotFound)
-    end
-  end
-
-  describe '::clone' do
-    let(:target) { clone_path('nginx') }
-
-    it 'clones the repository to the target path' do
-      origin_uri = git_origin_for('nginx')
-      Berkshelf::Git.clone(origin_uri, target)
-
-      expect(target).to exist
-      expect(target).to be_directory
-    end
-  end
-
-  describe '::checkout' do
-    let(:repo_path) { clone_path('nginx') }
-    let(:repo) {
-      origin_uri = git_origin_for('nginx', tags: ['1.0.1', '1.0.2'], branches: ['topic', 'next_topic'])
-      git.clone(origin_uri, repo_path)
-    }
-
-    shared_examples 'able to checkout git ref' do |test_ref|
-      it 'checks out the specified ref of the given repository' do
-        git.checkout(repo, ref)
-
-        Dir.chdir repo_path do
-          test_ref ||= ref
-          expect(%x[git rev-parse #{test_ref}]).to eq(%x[git rev-parse HEAD])
-        end
-      end
-    end
-
-    context 'with sha commit id' do
-      let(:ref) { sha_for_ref('nginx', '1.0.1') }
-
-      it_behaves_like 'able to checkout git ref'
-    end
-
-    context 'with tags' do
-      let(:ref) { '1.0.1' }
-
-      it_behaves_like 'able to checkout git ref'
-
-      context 'after checking out another tag' do
-        let(:other_tag) { '1.0.2' }
-        before do
-          git.checkout(repo, other_tag)
-          Dir.chdir repo_path do
-            shell_out "echo 'uncommitted change' >> content_file"
-          end
-        end
-
-        it_behaves_like 'able to checkout git ref'
-      end
-    end
-
-    context 'with branches' do
-      let(:ref) { 'topic' }
-
-      it_behaves_like 'able to checkout git ref', 'origin/topic'
-
-      context 'after checking out another branch' do
-        let(:other_branch) { 'next_topic' }
-        before do
-          git.checkout(repo, other_branch)
-          Dir.chdir repo_path do
-            shell_out "echo 'uncommitted change' >> content_file"
-          end
-        end
-
-        it_behaves_like 'able to checkout git ref', 'origin/topic'
-      end
-    end
-  end
-
-  describe '::rev_parse' do
-    let(:repo_path) { clone_path('nginx') }
-    before(:each) do |example|
-      origin_uri = git_origin_for('nginx', tags: ['1.1.1'])
-      Berkshelf::Git.clone(origin_uri, repo_path)
-      Berkshelf::Git.checkout(repo_path, sha_for_ref('nginx', '1.1.1'))
-    end
-
-    it 'returns the ref for HEAD' do
-      rev = Berkshelf::Git.rev_parse(repo_path)
-      ref = sha_for_ref('nginx', '1.1.1')
-
-      expect(rev).to eql(ref)
-    end
-  end
-
-  describe '::show_ref' do
-    let(:repo_path) { clone_path('nginx') }
-    let(:tags) { ['1.0.1'] }
-    let(:branches) { ['topic'] }
-    let!(:repo) {
-      origin_uri = git_origin_for('nginx', tags: tags, branches: branches)
-      git.clone(origin_uri, repo_path)
-    }
-
-    it 'returns the commit id for the given tag' do
-      show = git.show_ref(repo_path, '1.0.1')
-      ref = sha_for_ref('nginx', '1.0.1')
-
-      expect(show).to eq(ref)
-    end
-
-    it 'returns the commit id for the given branch' do
-      show = git.show_ref(repo_path, 'topic')
-      ref = sha_for_ref('nginx', 'topic')
-      expect(show).to eq(ref)
-    end
-
-    context 'with an ambiguous ref' do
-      let(:tags) { ['topic'] }
-      let(:branches) { ['topic'] }
-
-      it 'raises an error' do
-        expect {
-          git.show_ref(repo_path, 'topic')
-        }.to raise_error(Berkshelf::AmbiguousGitRef)
-      end
-    end
-  end
-
-  describe '::revision_from_ref' do
-    let(:repo_path) { clone_path('nginx') }
-    let(:tags) { ['1.0.1'] }
-    let(:branches) { ['topic'] }
-    let!(:repo) {
-      origin_uri = git_origin_for('nginx', tags: tags, branches: branches)
-      git.clone(origin_uri, repo_path)
-    }
-
-    context 'with sha commit id' do
-      let(:revision) { sha_for_ref('nginx', '1.0.1') }
-      it 'returns the passed revision' do
-        rev = git.revision_from_ref(repo_path, revision)
-        expect(rev).to eq(revision)
-      end
-    end
-
-    context 'with tag' do
-      let(:revision) { sha_for_ref('nginx', '1.0.1') }
-      it 'returns the revision' do
-        rev = git.revision_from_ref(repo_path, '1.0.1')
-        expect(rev).to eq(revision)
-      end
-    end
-
-    context 'with branch' do
-      let(:revision) { sha_for_ref('nginx', 'topic') }
-      it 'returns the revision' do
-        rev = git.revision_from_ref(repo_path, 'topic')
-        expect(rev).to eq(revision)
-      end
-    end
-
-    context 'with an invalid ref' do
-      let(:ref) { 'foobar' }
-      it 'raises an error' do
-        expect {
-          git.revision_from_ref(repo_path, ref)
-        }.to raise_error(Berkshelf::InvalidGitRef)
-      end
-    end
-  end
-
-  let(:readonly_uri) { 'git://github.com/reset/thor-foodcritic.git' }
-  let(:https_uri) { 'https://github.com/reset/solve.git' }
-  let(:http_uri) { 'http://github.com/reset/solve.git' }
-  let(:invalid_uri) { '/something/on/disk' }
-
-  describe '::validate_uri' do
-    context 'given a valid Git read-only URI' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri(readonly_uri)).to be_true
-      end
-    end
-
-    context 'given a valid Git HTTPS URI' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri(https_uri)).to be_true
-      end
-    end
-
-    context 'given a valid Github SSH URI' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri('git@github.com:reset/solve.git')).to be_true
-      end
-    end
-
-    context "given a valid SSH URI without an 'organization'" do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri('gituser@githost:solve.git')).to be_true
-      end
-    end
-
-    context 'given a valid git+ssh URI without an username' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri('git+ssh://host.com/repo')).to be_true
-      end
-    end
-
-    context 'given a valid git+ssh URI with an username' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri('git+ssh://user@host.com/repo')).to be_true
-      end
-    end
-
-    context 'given a valid URI with a dash in the hostname' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri('git://user@git-host.com/repo')).to be_true
-      end
-    end
-
-    context 'given a valid URI with host being a subdomain' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri('git://user@git.host.com/repo')).to be_true
-      end
-    end
-
-    context 'given a valid git+ssh URI with home directory expansion' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri('git+ssh://user@host.com/~repo')).to be_true
-      end
-    end
-
-    context 'given an invalid URI' do
-      it 'returns false' do
-        expect(Berkshelf::Git.validate_uri(invalid_uri)).to be_false
-      end
-    end
-
-    context 'given a HTTP URI' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri(http_uri)).to be_true
-      end
-    end
-
-    context 'given an integer' do
-      it 'returns false' do
-        expect(Berkshelf::Git.validate_uri(123)).to be_false
-      end
-    end
-  end
-
-  describe '::validate_uri!' do
-    context 'given a valid Git read-only URI' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri!(readonly_uri)).to be_true
-      end
-    end
-
-    context 'given a valid Git HTTPS URI' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri!(https_uri)).to be_true
-      end
-    end
-
-    context 'given a valid Git SSH URI' do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri!('git@github.com:reset/solve.git')).to be_true
-      end
-    end
-
-    context "given a valid SSH URI without an 'organization'" do
-      it 'returns true' do
-        expect(Berkshelf::Git.validate_uri('gituser@githost:solve.git')).to be_true
-      end
-    end
-
-    context 'given an invalid URI' do
-      it 'raises InvalidGitURI' do
-        expect {
-          Berkshelf::Git.validate_uri!(invalid_uri)
-        }.to raise_error(Berkshelf::InvalidGitURI)
-      end
-    end
-
-    context 'given a HTTP URI' do
-      it 'raises InvalidGitURI' do
-        expect(Berkshelf::Git.validate_uri!(http_uri)).to be_true
-      end
-    end
-
-    context 'given an integer' do
-      it 'raises InvalidGitURI' do
-        expect {
-          Berkshelf::Git.validate_uri!(123)
-        }.to raise_error(Berkshelf::InvalidGitURI)
-      end
-    end
-  end
-end