berkshelf 0.1.1

data/spec/unit/berkshelf/cookbook_store_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe CookbookStore do
+    subject { CookbookStore.new(tmp_path.join("cbstore_rspec")) }
+
+    describe "#initialize" do
+      it "creates the storage_path" do
+        storage_path = tmp_path.join("random_storage")
+        subject.class.new(storage_path)
+
+        storage_path.should exist
+      end
+    end
+
+    describe "#cookbook_path" do
+      let(:cookbook_name) { "nginx" }
+      let(:cookbook_version) { "0.101.2" }
+
+      before(:each) do
+        @cb_path = subject.cookbook_path(cookbook_name, cookbook_version)
+      end
+
+      it "returns an instance of Pathname" do
+        @cb_path.should be_a(Pathname)
+      end
+
+      it "returns a Cookbook Version's filepath within the storage path" do
+        @cb_path.dirname.should eql(subject.storage_path)
+      end
+
+      it "returns a basename containing the cookbook name and version separated by a dash" do
+        @cb_path.basename.to_s.should eql("#{cookbook_name}-#{cookbook_version}")
+      end
+    end
+
+    describe "#downloaded?" do
+      it "returns true if the store contains a Cookbook of the given name and version" do
+        CookbookSource.new("nginx", "0.101.2").download(subject.storage_path)
+
+        subject.downloaded?("nginx", "0.101.2").should be_true
+      end
+
+      it "returns false if the store does not contain a Cookbook of the given name and version" do
+        subject.downloaded?("notthere", "0.0.0").should be_false
+      end
+    end
+
+    describe "#cookbook" do
+      subject { CookbookStore.new(fixtures_path.join("cookbooks")) }
+
+      it "returns a CachedCookbook if the specified cookbook version exists" do
+        subject.cookbook("example_cookbook", "0.5.0").should be_a(CachedCookbook)
+      end
+
+      it "returns nil if the specified cookbook version does not exist" do
+        subject.cookbook("doesnotexist", "0.1.0").should be_nil
+      end
+    end
+
+    describe "#cookbooks" do
+      it "returns a list of CachedCookbooks" do
+        CookbookSource.new("nginx", "0.101.2").download(subject.storage_path)
+
+        subject.cookbooks.each do |cb|
+          cb.should be_a(CachedCookbook)
+        end
+      end
+    end
+  end
+end

data/spec/unit/berkshelf/cookbookfile_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe Berksfile do
+    describe "ClassMethods" do
+      subject { Berksfile }
+
+      let(:content) do
+<<-EOF
+cookbook 'ntp', '<= 1.0.0'
+cookbook 'mysql'
+cookbook 'nginx', '< 0.101.2'
+cookbook 'ssh_known_hosts2', :git => 'https://github.com/erikh/chef-ssh_known_hosts2.git'
+EOF
+      end
+
+      describe "#read" do
+        it "reads the content of a Berksfile and adds the sources to the Shelf" do
+          cbfile = subject.read(content)
+
+          ['ntp', 'mysql', 'nginx', 'ssh_known_hosts2'].each do |name|
+            cbfile.should have_source(name)
+          end
+        end
+
+        it "returns an instance of Berksfile" do
+          subject.read(content).should be_a(Berksfile)
+        end
+      end
+
+      describe "#from_file" do
+        let(:cookbook_file) { fixtures_path.join('lockfile_spec', 'with_lock', 'Berksfile') }
+
+        it "reads a Berksfile and returns an instance Berksfile" do
+          subject.from_file(cookbook_file).should be_a(Berksfile)
+        end
+
+        context "when Berksfile does not exist at given path" do
+          let(:bad_path) { tmp_path.join("thisdoesnotexist") }
+
+          it "raises BerksfileNotFound" do
+            lambda {
+              subject.from_file(bad_path)
+            }.should raise_error(BerksfileNotFound)
+          end
+        end
+      end
+
+      describe "#filter_sources" do
+        context "given one of the sources is a member of one of the excluded groups" do
+          let(:excluded_groups) { [:nautilus, :skarner] }
+          let(:source_one) { double('source_one') }
+          let(:source_two) { double('source_two') }
+
+          before(:each) do
+            source_one.stub(:groups) { [:nautilus] }
+            source_two.stub(:groups) { [:riven] }
+            @sources = [source_one, source_two]
+          end
+
+          it "returns an array without sources that were members of the excluded groups" do
+            result = subject.filter_sources(@sources, excluded_groups)
+
+            result.should_not include(source_one)
+          end
+
+          it "does not remove sources that were not a member of the excluded groups" do
+            result = subject.filter_sources(@sources, excluded_groups)
+
+            result.should include(source_two)
+          end
+        end
+      end
+    end
+
+    let(:source_one) { double('source_one', name: "nginx") }
+    let(:source_two) { double('source_two', name: "mysql") }
+
+    subject do
+      cbf = Berksfile.new
+      cbf.add_source(source_one)
+      cbf.add_source(source_two)
+      cbf
+    end
+
+    describe "#sources" do
+      it "returns all CookbookSources added to the instance of Berksfile" do
+        result = subject.sources
+
+        result.should have(2).items
+        result.should include(source_one)
+        result.should include(source_two)
+      end
+
+      context "given the option :exclude" do
+        it "filters the sources before returning them" do
+          subject.class.should_receive(:filter_sources).with(subject.sources, :nautilus)
+
+          subject.sources(exclude: :nautilus)
+        end
+      end
+    end
+
+    describe "#groups" do
+      before(:each) do
+        source_one.stub(:groups) { [:nautilus, :skarner] }
+        source_two.stub(:groups) { [:nautilus, :riven] }
+      end
+
+      it "returns a hash containing keys for every group a source is a member of" do
+        subject.groups.keys.should have(3).items
+        subject.groups.should have_key(:nautilus)
+        subject.groups.should have_key(:skarner)
+        subject.groups.should have_key(:riven)
+      end
+
+      it "returns an Array of CookbookSources who are members of the group for value" do
+        subject.groups[:nautilus].should include(source_one)
+        subject.groups[:nautilus].should include(source_two)
+        subject.groups[:riven].should_not include(source_one)
+      end
+    end
+
+    describe "#install" do
+      let(:resolver) { double('resolver') }
+      before(:each) { Berkshelf::Resolver.stub(:new) { resolver } }
+
+      context "when a lockfile is not present" do
+        before(:each) do
+          subject.should_receive(:lockfile_present?).and_return(false)
+          resolver.should_receive(:sources).and_return([])
+        end
+
+        it "creates a new resolver and finds a solution by calling resolve on the resolver" do
+          resolver.should_receive(:resolve)
+
+          subject.install
+        end
+
+        it "writes a lockfile with the resolvers sources" do
+          resolver.should_receive(:resolve)
+          subject.should_receive(:write_lockfile).with([])
+
+          subject.install
+        end
+      end
+
+      context "when a lockfile is present" do
+        before(:each) { subject.should_receive(:lockfile_present?).and_return(true) }
+
+        it "does not write a new lock file" do
+          resolver.should_receive(:resolve)
+          subject.should_not_receive(:write_lockfile)
+
+          subject.install
+        end
+      end
+    end
+  end
+end

data/spec/unit/berkshelf/downloader_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe Downloader do
+    subject { Downloader.new(CookbookStore.new(tmp_path)) }
+    let(:source) { CookbookSource.new("sparkle_motion") }
+
+    describe "#enqueue" do
+      it "should add a source to the queue" do
+        subject.enqueue(source)
+
+        subject.queue.should have(1).source
+      end
+
+      it "should not allow you to add an invalid source" do
+        lambda {
+          subject.enqueue("a string, not a source")
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    describe "#dequeue" do
+      before(:each) { subject.enqueue(source) }
+
+      it "should remove a source from the queue" do
+        subject.dequeue(source)
+
+        subject.queue.should be_empty
+      end
+    end
+
+    describe "#download_all" do
+      let(:source_one) { CookbookSource.new("nginx") }
+      let(:source_two) { CookbookSource.new("mysql") }
+
+      before(:each) do
+        subject.enqueue source_one
+        subject.enqueue source_two
+      end
+
+      it "should remove each item from the queue after a successful download" do
+        subject.download_all
+
+        subject.queue.should be_empty
+      end
+
+      it "should not remove the item from the queue if the download failed" do
+        subject.enqueue CookbookSource.new("does_not_exist_no_way")
+        subject.download_all
+
+        subject.queue.should have(1).sources
+      end
+
+      it "should return a TXResultSet" do
+        results = subject.download_all
+
+        results.should be_a(TXResultSet)
+      end
+    end
+
+    describe "#download" do
+      let(:source) { CookbookSource.new("nginx") }
+      let(:bad_source) { CookbookSource.new("donowaytexists") }
+
+      it "returns a TXResult" do
+        subject.download(source).should be_a(TXResult)
+      end
+
+      context "when successful" do
+        it "returns a successesful TXResult" do
+          subject.download(source).should be_success
+        end
+      end
+
+      context "when failure" do
+        it "returns a failed TXResult" do
+          subject.download(bad_source).should be_failed
+        end
+      end
+    end
+  end
+end

data/spec/unit/berkshelf/dsl_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'berkshelf/dsl'
+
+module Berkshelf
+  describe DSL do
+    subject do
+      Class.new do
+        include Berkshelf::DSL
+      end.new
+    end
+
+    describe "#cookbook" do
+      it "calls add source to the instance of the implementing class with a CookbookSource" do
+        subject.should_receive(:add_source).with(kind_of(CookbookSource))
+        
+        subject.cookbook "ntp"
+      end
+    end
+
+    describe '#group' do
+      it "calls add source to the instance of the implementing class with a CookbookSource" do
+        subject.should_receive(:add_source).with(kind_of(CookbookSource))
+        
+        subject.group "awesome" do
+          subject.cookbook "ntp"
+        end
+      end
+    end
+
+    describe "#metadata" do
+      before(:each) do
+        Dir.chdir fixtures_path.join('cookbooks/example_cookbook')
+      end
+
+      it "calls add source to the instance of the implementing class with a CookbookSource" do
+        subject.should_receive(:add_source).with(kind_of(CookbookSource))
+        
+        subject.metadata
+      end
+    end
+  end
+end

data/spec/unit/berkshelf/git_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe Git do
+    describe "ClassMethods" do
+      subject { Git }
+
+      describe "#find_git" do
+        it "should find git" do
+          subject.find_git.should_not be_nil
+        end
+
+        it "should raise if it can't find git" do
+          begin
+            path = ENV["PATH"]
+            ENV["PATH"] = ""
+
+            lambda { subject.find_git }.should raise_error
+          ensure
+            ENV["PATH"] = path
+          end
+        end
+      end
+
+      describe "#clone" do
+        let(:target) { tmp_path.join("nginx") }
+
+        it "clones the repository to the target path" do
+          subject.clone("git://github.com/opscode-cookbooks/nginx.git", target)
+
+          target.should exist
+          target.should be_directory
+        end
+      end
+
+      describe "#checkout" do
+        let(:repo_path) { tmp_path.join("nginx") }
+        let(:repo) { subject.clone("git://github.com/opscode-cookbooks/nginx.git", repo_path) }
+        let(:tag) { "0.101.2" }
+
+        it "checks out the specified path of the given repository" do
+          subject.checkout(repo, tag)
+
+          Dir.chdir repo_path do
+            %x[git rev-parse #{tag}].should == %x[git rev-parse HEAD]
+          end
+        end
+      end
+
+      describe "#rev_parse" do
+        let(:repo_path) { tmp_path.join("nginx") }
+        before(:each) do
+          subject.clone("git://github.com/opscode-cookbooks/nginx.git", repo_path)
+          subject.checkout(repo_path, "0e4887d9eef8cb83972f974a85890983c8204c3b")
+        end
+
+        it "returns the ref for HEAD" do
+          subject.rev_parse(repo_path).should eql("0e4887d9eef8cb83972f974a85890983c8204c3b")
+        end
+      end
+    end
+  end
+end

data/spec/unit/berkshelf/init_generator_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe InitGenerator do
+    subject { InitGenerator }
+
+    let(:target_root) { tmp_path.join("some_cookbook") }
+
+    context "with default options" do
+      before do
+        generator = subject.new([], :path => target_root)
+        capture(:stdout) { generator.invoke_all }
+      end
+
+      specify do
+        target_root.should have_structure {
+          file "Berksfile"
+          no_file ".chefignore"
+        }
+      end
+    end
+
+    context "with a .chefignore" do
+      before do
+        generator = subject.new([], :path => target_root, :chefignore => true)
+        capture(:stdout) { generator.invoke_all }
+      end
+
+      specify do
+        target_root.should have_structure {
+          file "Berksfile"
+          file ".chefignore"
+        }
+      end
+    end
+
+    context "with a metadata entry in the Berksfile" do
+      before do
+        generator = subject.new([], :path => target_root, :metadata_entry => true)
+        capture(:stdout) { generator.invoke_all }
+      end
+
+      specify do
+        target_root.should have_structure {
+          file "Berksfile" do
+            contains "metadata"
+          end
+        }
+      end
+    end
+  end
+end