berkshelf 3.1.5 → 3.2.0

data/spec/unit/berkshelf/core_ext/file_utils_spec.rb

@@ -7,9 +7,9 @@ describe FileUtils do
     let(:options) { double('options') }
 
     it 'replaces mv with cp_r and rm_rf' do
-      subject.stub(:windows?) { true }
-      FileUtils.should_receive(:cp_r).with(src, dest, options)
-      FileUtils.should_receive(:rm_rf).with(src)
+      allow(subject).to receive(:windows?) { true }
+      expect(FileUtils).to receive(:cp_r).with(src, dest, options)
+      expect(FileUtils).to receive(:rm_rf).with(src)
 
       FileUtils.mv(src, dest, options)
     end

data/spec/unit/berkshelf/core_ext/pathname_spec.rb

@@ -10,17 +10,26 @@ describe Pathname do
 
     context "when the path contains a metadata.json file" do
       before { FileUtils.touch(metadata_json) }
-      its(:cookbook?) { should be_true }
+
+      it "is a cookbook" do
+        expect(subject.cookbook?).to be(true)
+      end
     end
 
     context "when the path contains a metadata.rb file" do
       before { FileUtils.touch(metadata_rb) }
-      its(:cookbook?) { should be_true }
+
+      it "is a cookbook" do
+        expect(subject.cookbook?).to be(true)
+      end
     end
 
     context "when the path does not contain a metadata.json or metadata.rb file" do
       before { FileUtils.rm_f(metadata_rb) && FileUtils.rm_f(metadata_json) }
-      its(:cookbook?) { should be_false }
+
+      it "is not a cookbook" do
+        expect(subject.cookbook?).to be(false)
+      end
     end
   end
 
@@ -30,17 +39,25 @@ describe Pathname do
     subject { Pathname.new(cookbook_path) }
 
     context "when in the root of a cookbook" do
-      its(:cookbook_root) { should eql(root_path) }
+      it "has the correct root" do
+        expect(subject.cookbook_root).to eq(root_path)
+      end
     end
 
     context "when in the structure of a cookbook" do
       let(:cookbook_path) { root_path.join("recipes") }
-      its(:cookbook_root) { should eql(root_path) }
+
+      it "has the correct root" do
+        expect(subject.cookbook_root).to eq(root_path)
+      end
     end
 
     context "when not within the structure of a cookbook" do
       let(:cookbook_path) { "/" }
-      its(:cookbook_root) { should be_nil }
+
+      it "has the correct root" do
+        expect(subject.cookbook_root).to be(nil)
+      end
     end
   end
 end

data/spec/unit/berkshelf/dependency_spec.rb

@@ -121,13 +121,13 @@ describe Berkshelf::Dependency do
 
   describe '#installed?' do
     it 'returns true if self.cached_cookbook is not nil' do
-      subject.stub(:cached_cookbook) { double('cb') }
-      expect(subject.installed?).to be_true
+      allow(subject).to receive(:cached_cookbook) { double('cb') }
+      expect(subject.installed?).to be(true)
     end
 
     it 'returns false if self.cached_cookbook is nil' do
-      subject.stub(:cached_cookbook) { nil }
-      expect(subject.installed?).to be_false
+      allow(subject).to receive(:cached_cookbook) { nil }
+      expect(subject.installed?).to be(false)
     end
   end
 end

data/spec/unit/berkshelf/downloader_spec.rb

@@ -5,7 +5,7 @@ describe Berkshelf::Downloader do
   subject { described_class.new(berksfile) }
 
   describe "#download" do
-    pending
+    skip
   end
 
   describe "#try_download" do
@@ -35,5 +35,9 @@ describe Berkshelf::Downloader do
       expect(rest).to receive(:download).with(name, version)
       subject.try_download(source, name, version)
     end
+
+    it "supports the 'file_store' location type" do
+      skip
+    end
   end
 end

data/spec/unit/berkshelf/errors_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
 describe Berkshelf::BerkshelfError do
-  pending
+  skip
 end

data/spec/unit/berkshelf/file_syncer_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe FileSyncer do
+    describe '#glob' do
+      before do
+        FileUtils.mkdir_p(File.join(tmp_path, 'folder'))
+        FileUtils.mkdir_p(File.join(tmp_path, '.hidden_folder'))
+
+        FileUtils.touch(File.join(tmp_path, 'folder', 'file'))
+        FileUtils.touch(File.join(tmp_path, '.hidden_file'))
+      end
+
+      let(:list) do
+        described_class
+          .glob("#{tmp_path}/**/*")
+          .map { |item| item.sub("#{tmp_path}/", '') }
+      end
+
+      it 'includes regular files' do
+        expect(list).to include('folder')
+        expect(list).to include('folder/file')
+      end
+
+      it 'ignores .' do
+        expect(list).to_not include('.')
+      end
+
+      it 'ignores ..' do
+        expect(list).to_not include('..')
+      end
+
+      it 'includes hidden files' do
+        expect(list).to include('.hidden_file')
+      end
+
+      it 'includes hidden folders' do
+        expect(list).to include('.hidden_folder')
+      end
+    end
+
+    describe '#sync' do
+      let(:source) do
+        source = File.join(tmp_path, 'source')
+        FileUtils.mkdir_p(source)
+
+        FileUtils.touch(File.join(source, 'file_a'))
+        FileUtils.touch(File.join(source, 'file_b'))
+        FileUtils.touch(File.join(source, 'file_c'))
+
+        FileUtils.mkdir_p(File.join(source, 'folder'))
+        FileUtils.touch(File.join(source, 'folder', 'file_d'))
+        FileUtils.touch(File.join(source, 'folder', 'file_e'))
+
+        FileUtils.mkdir_p(File.join(source, '.dot_folder'))
+        FileUtils.touch(File.join(source, '.dot_folder', 'file_f'))
+
+        FileUtils.touch(File.join(source, '.file_g'))
+        source
+      end
+
+      let(:destination) { File.join(tmp_path, 'destination') }
+
+      context 'when the destination is empty' do
+        it 'syncs the directories' do
+          described_class.sync(source, destination)
+
+          expect("#{destination}/file_a").to be_a_file
+          expect("#{destination}/file_b").to be_a_file
+          expect("#{destination}/file_c").to be_a_file
+          expect("#{destination}/folder/file_d").to be_a_file
+          expect("#{destination}/folder/file_e").to be_a_file
+          expect("#{destination}/.dot_folder/file_f").to be_a_file
+          expect("#{destination}/.file_g").to be_a_file
+        end
+      end
+
+      context 'when the directory exists' do
+        before { FileUtils.mkdir_p(destination) }
+
+        it 'deletes existing files and folders' do
+          FileUtils.mkdir_p("#{destination}/existing_folder")
+          FileUtils.mkdir_p("#{destination}/.existing_folder")
+          FileUtils.touch("#{destination}/existing_file")
+          FileUtils.touch("#{destination}/.existing_file")
+
+          described_class.sync(source, destination)
+
+          expect("#{destination}/file_a").to be_a_file
+          expect("#{destination}/file_b").to be_a_file
+          expect("#{destination}/file_c").to be_a_file
+          expect("#{destination}/folder/file_d").to be_a_file
+          expect("#{destination}/folder/file_e").to be_a_file
+          expect("#{destination}/.dot_folder/file_f").to be_a_file
+          expect("#{destination}/.file_g").to be_a_file
+
+          expect("#{destination}/existing_folder").to_not be_a_directory
+          expect("#{destination}/.existing_folder").to_not be_a_directory
+          expect("#{destination}/existing_file").to_not be_a_file
+          expect("#{destination}/.existing_file").to_not be_a_file
+        end
+      end
+
+      context 'with deeply nested paths and symlinks' do
+        let(:source) do
+          source = File.join(tmp_path, 'source')
+          FileUtils.mkdir_p(source)
+
+          FileUtils.mkdir_p(File.join(source, 'bin'))
+               FileUtils.touch(File.join(source, 'bin', 'apt'))
+               FileUtils.touch(File.join(source, 'bin', 'yum'))
+
+          FileUtils.touch(File.join(source, 'LICENSE'))
+
+          FileUtils.mkdir_p(File.join(source, 'include'))
+          FileUtils.mkdir_p(File.join(source, 'include', 'linux'))
+               FileUtils.touch(File.join(source, 'include', 'linux', 'init.ini'))
+
+          FileUtils.mkdir_p(File.join(source, 'source'))
+          FileUtils.mkdir_p(File.join(source, 'source', 'bin'))
+               FileUtils.touch(File.join(source, 'source', 'bin', 'apt'))
+               FileUtils.touch(File.join(source, 'source', 'bin', 'yum'))
+               FileUtils.touch(File.join(source, 'source', 'LICENSE'))
+
+          FileUtils.mkdir_p(File.join(source, 'empty_directory'))
+
+          FileUtils.mkdir_p(File.join(source, 'links'))
+                 FileUtils.touch(File.join(source, 'links', 'home.html'))
+                 FileUtils.ln_s("./home.html", "#{source}/links/index.html")
+                 FileUtils.ln_s("./home.html", "#{source}/links/default.html")
+                 FileUtils.ln_s("../source/bin/apt", "#{source}/links/apt")
+
+          FileUtils.ln_s('/foo/bar', "#{source}/root")
+
+          source
+        end
+
+        it 'copies relative and absolute symlinks' do
+          described_class.sync(source, destination)
+
+          expect("#{destination}/bin").to be_a_directory
+          expect("#{destination}/bin/apt").to be_a_file
+          expect("#{destination}/bin/yum").to be_a_file
+
+          expect("#{destination}/LICENSE").to be_a_file
+
+          expect("#{destination}/include").to be_a_directory
+          expect("#{destination}/include/linux").to be_a_directory
+          expect("#{destination}/include/linux/init.ini").to be_a_file
+
+          expect("#{destination}/source").to be_a_directory
+          expect("#{destination}/source/bin").to be_a_directory
+          expect("#{destination}/source/bin/apt").to be_a_file
+          expect("#{destination}/source/bin/yum").to be_a_file
+          expect("#{destination}/source/LICENSE").to be_a_file
+
+          expect("#{destination}/empty_directory").to be_a_directory
+
+          expect("#{destination}/links").to be_a_directory
+          expect("#{destination}/links/home.html").to be_a_file
+          expect("#{destination}/links/index.html").to be_a_symlink_to("./home.html")
+          expect("#{destination}/links/default.html").to be_a_symlink_to("./home.html")
+          expect("#{destination}/links/apt").to be_a_symlink_to("../source/bin/apt")
+
+          expect("#{destination}/root").to be_a_symlink_to('/foo/bar')
+        end
+      end
+
+      context 'when :exclude is given' do
+        it 'does not copy files and folders that match the pattern' do
+          described_class.sync(source, destination, exclude: '.dot_folder')
+
+          expect("#{destination}/file_a").to be_a_file
+          expect("#{destination}/file_b").to be_a_file
+          expect("#{destination}/file_c").to be_a_file
+          expect("#{destination}/folder/file_d").to be_a_file
+          expect("#{destination}/folder/file_e").to be_a_file
+          expect("#{destination}/.dot_folder").to_not be_a_directory
+          expect("#{destination}/.dot_folder/file_f").to_not be_a_file
+          expect("#{destination}/.file_g").to be_a_file
+        end
+
+        it 'removes existing files and folders in destination' do
+          FileUtils.mkdir_p("#{destination}/existing_folder")
+          FileUtils.touch("#{destination}/existing_file")
+          FileUtils.mkdir_p("#{destination}/.dot_folder")
+          FileUtils.touch("#{destination}/.dot_folder/file_f")
+
+          described_class.sync(source, destination, exclude: '.dot_folder')
+
+          expect("#{destination}/file_a").to be_a_file
+          expect("#{destination}/file_b").to be_a_file
+          expect("#{destination}/file_c").to be_a_file
+          expect("#{destination}/folder/file_d").to be_a_file
+          expect("#{destination}/folder/file_e").to be_a_file
+          expect("#{destination}/.dot_folder").to_not be_a_directory
+          expect("#{destination}/.dot_folder/file_f").to_not be_a_file
+          expect("#{destination}/.file_g").to be_a_file
+
+          expect("#{destination}/existing_folder").to_not be_a_directory
+          expect("#{destination}/existing_file").to_not be_a_file
+        end
+      end
+    end
+  end
+end

data/spec/unit/berkshelf/init_generator_spec.rb

@@ -6,7 +6,7 @@ describe Berkshelf::InitGenerator do
   let(:kitchen_generator) { double('kitchen-generator', invoke_all: nil) }
 
   before do
-    Kitchen::Generator::Init.stub(:new).with(any_args()).and_return(kitchen_generator)
+    allow(Kitchen::Generator::Init).to receive(:new).with(any_args()).and_return(kitchen_generator)
     FileUtils.mkdir_p(target)
     File.open(File.join(target, 'metadata.rb'), 'w') do |f|
       f.write("name 'some_cookbook'")
@@ -25,13 +25,12 @@ describe Berkshelf::InitGenerator do
         file '.gitignore'
         file 'Berksfile'
         file 'Gemfile' do
-          contains "gem 'berkshelf'"
+          contains %(gem 'berkshelf')
         end
         file 'Vagrantfile' do
-          contains 'recipe[some_cookbook::default]'
-          contains ' config.omnibus.chef_version = :latest'
-          contains 'config.vm.box = "chef/ubuntu-14.04"'
-          contains 'config.vm.box_url = "https://vagrantcloud.com/chef/ubuntu-14.04/version/1/provider/virtualbox.box"'
+          contains %(recipe[some_cookbook::default])
+          contains %(config.omnibus.chef_version = 'latest')
+          contains %(config.vm.box = 'chef/ubuntu-14.04')
         end
         file 'chefignore'
       }
@@ -175,54 +174,52 @@ describe Berkshelf::InitGenerator do
     end
   end
 
-  context "given the 'vagrant.omnibus.enabled' option set to false" do
+  context "given the 'vagrant.omnibus.version' option set" do
     before do
-      Berkshelf::Config.instance.vagrant.omnibus.enabled = false
+      Berkshelf::Config.instance.vagrant.omnibus.version = "11.4.4"
       capture(:stdout) {
         Berkshelf::InitGenerator.new([target]).invoke_all
       }
     end
 
-    it "generates a Vagrantfile without the 'config.omnibus.chef_version' value set" do
+    it "generates a Vagrantfile with the 'config.omnibus.chef_version' value set" do
       expect(target).to have_structure {
         file 'Vagrantfile' do
-          contains "#config.omnibus.chef_version"
+          contains "config.omnibus.chef_version = '11.4.4'"
         end
       }
     end
   end
 
-  context "given the 'vagrant.omnibus.version' option set" do
+  context "given the 'vagrant.omnibus.version' option set to 'latest'" do
     before do
-      Berkshelf::Config.instance.vagrant.omnibus.enabled = true
-      Berkshelf::Config.instance.vagrant.omnibus.version = "11.4.4"
+      Berkshelf::Config.instance.vagrant.omnibus.version = "latest"
       capture(:stdout) {
         Berkshelf::InitGenerator.new([target]).invoke_all
       }
     end
 
-    it "generates a Vagrantfile with the 'config.omnibus.chef_version' value set" do
+    it "generates a Vagrantfile with the 'config.omnibus.chef_version' value set to :latest" do
       expect(target).to have_structure {
         file 'Vagrantfile' do
-          contains " config.omnibus.chef_version = \"11.4.4\""
+          contains " config.omnibus.chef_version = 'latest'"
         end
       }
     end
   end
 
-  context "given the 'vagrant.omnibus.version' option set to 'latest'" do
+  context "given the 'vagrant.vm.box_url' option set" do
     before do
-      Berkshelf::Config.instance.vagrant.omnibus.enabled = true
-      Berkshelf::Config.instance.vagrant.omnibus.version = "latest"
+      Berkshelf::Config.instance.vagrant.vm.box_url = "https://vagrantcloud.com/chef/ubuntu-14.04/version/1/provider/virtualbox.box"
       capture(:stdout) {
         Berkshelf::InitGenerator.new([target]).invoke_all
       }
     end
 
-    it "generates a Vagrantfile with the 'config.omnibus.chef_version' value set to :latest" do
+    it "generates a Vagrantfile with the 'config.vm.box_url' value set" do
       expect(target).to have_structure {
         file 'Vagrantfile' do
-          contains " config.omnibus.chef_version = :latest"
+          contains "config.vm.box_url = 'https://vagrantcloud.com/chef/ubuntu-14.04/version/1/provider/virtualbox.box'"
         end
       }
     end
@@ -230,8 +227,8 @@ describe Berkshelf::InitGenerator do
 
   context 'with the chef_minitest option true' do
     before(:each) do
-        Berkshelf::Resolver.stub(:resolve) { resolver }
-        pending 'Runs fine with no mock for the HTTP call on the first pass, subsequent passes throw errors'
+        allow(Berkshelf::Resolver).to receive(:resolve) { resolver }
+        skip 'Runs fine with no mock for the HTTP call on the first pass, subsequent passes throw errors'
         capture(:stdout) {
           Berkshelf::InitGenerator.new([target], chef_minitest: true).invoke_all
         }

data/spec/unit/berkshelf/installer_spec.rb

@@ -10,11 +10,11 @@ describe Berkshelf::Installer do
     let(:source_two) { double('two', uri: 'https://api.chef.org') }
     let(:sources) { [ source_one, source_two ] }
 
-    before { berksfile.stub(sources: sources) }
+    before { allow(berksfile).to receive_messages(sources: sources) }
 
     it "sends the message #universe on each source" do
-      source_one.should_receive(:build_universe)
-      source_two.should_receive(:build_universe)
+      expect(source_one).to receive(:build_universe)
+      expect(source_two).to receive(:build_universe)
 
       subject.build_universe
     end
@@ -22,15 +22,15 @@ describe Berkshelf::Installer do
 
   describe "#run" do
     context 'when a lockfile is not present' do
-      pending
+      skip
     end
 
     context 'when a value for :except is given' do
-      pending
+      skip
     end
 
     context 'when a value for :only is given' do
-      pending
+      skip
     end
   end
 end