omnibus 2.0.2 → 3.0.0

data/spec/spec_helper.rb

@@ -1,6 +1,3 @@
-# Why isn't this already required in omnibus?
-require 'rake/dsl_definition'
-
 require 'omnibus'
 require 'fauxhai'
 
@@ -19,6 +16,14 @@ module Omnibus
     def project_path(name)
       File.join(SPEC_DATA, 'projects', "#{name}.rb")
     end
+
+    def fixtures_path
+      File.expand_path('../fixtures', __FILE__)
+    end
+
+    def tmp_path
+      File.expand_path('../../tmp', __FILE__)
+    end
   end
 end
 
@@ -28,6 +33,12 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.treat_symbols_as_metadata_keys_with_true_values = true
 
+  # Clear the tmp_path on each run
+  config.before(:each) do
+    FileUtils.rm_rf(tmp_path)
+    FileUtils.mkdir_p(tmp_path)
+  end
+
   # Force the expect syntax
   config.expect_with :rspec do |c|
     c.syntax = :expect

data/spec/sugar_spec.rb

@@ -0,0 +1,20 @@
+require 'omnibus/project'
+require 'omnibus/software'
+
+require 'spec_helper'
+
+describe Omnibus::Software do
+  it 'includes the Chef Sugar DSL methods' do
+    expect(described_class).to be_method_defined(:windows?)
+    expect(described_class).to be_method_defined(:vagrant?)
+    expect(described_class).to be_method_defined(:_64_bit?)
+  end
+end
+
+describe Omnibus::Project do
+  it 'includes the Chef Sugar DSL methods' do
+    expect(described_class).to be_method_defined(:windows?)
+    expect(described_class).to be_method_defined(:vagrant?)
+    expect(described_class).to be_method_defined(:_64_bit?)
+  end
+end

data/spec/{artifact_spec.rb → unit/artifact_spec.rb}

@@ -32,8 +32,6 @@ describe Omnibus::Artifact do
 
   let(:artifact) { Omnibus::Artifact.new(path, platforms,  version: '11.4.0-1') }
 
-  let(:flat_metadata) { artifact.flat_metadata }
-
   it 'has the path to the package' do
     expect(artifact.path).to eq(path)
   end
@@ -53,7 +51,8 @@ describe Omnibus::Artifact do
   end
 
   it "generates 'flat' metadata" do
-    expect(File).to receive(:open).at_least(2).with(path).and_return(content)
+    expect(File).to receive(:open).twice.with(path).and_return(content)
+    flat_metadata = artifact.flat_metadata
     expect(flat_metadata['platform']).to eq('el')
     expect(flat_metadata['platform_version']).to eq('5')
     expect(flat_metadata['arch']).to eq('x86_64')

data/spec/{config_spec.rb → unit/config_spec.rb}

@@ -19,12 +19,16 @@ module Omnibus
     end
 
     include_examples 'a configurable', :cache_dir, '/var/cache/omnibus/cache'
+    include_examples 'a configurable', :install_path_cache_dir, '/var/cache/omnibus/cache/install_path'
     include_examples 'a configurable', :source_dir, '/var/cache/omnibus/src'
     include_examples 'a configurable', :build_dir, '/var/cache/omnibus/build'
     include_examples 'a configurable', :package_dir, '/var/cache/omnibus/pkg'
     include_examples 'a configurable', :package_tmp, '/var/cache/omnibus/pkg-tmp'
     include_examples 'a configurable', :project_root, Dir.pwd
     include_examples 'a configurable', :install_dir, '/opt/chef'
+    include_examples 'a configurable', :build_dmg, true
+    include_examples 'a configurable', :dmg_window_bounds, '100, 100, 750, 600'
+    include_examples 'a configurable', :dmg_pkg_position, '535, 50'
     include_examples 'a configurable', :use_s3_caching, false
     include_examples 'a configurable', :s3_bucket, nil
     include_examples 'a configurable', :s3_access_key, nil

data/spec/unit/install_path_cache_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+require 'omnibus/util'
+require 'omnibus/install_path_cache'
+
+describe Omnibus::InstallPathCache do
+  let(:install_path) { '/opt/chef' }
+
+  let(:project) do
+    raw_project = <<-EOH
+name "demo"
+install_path "/opt/demo"
+build_version "1.0.0"
+maintainer 'Chef Software, Inc'
+homepage 'http://getchef.com'
+dependency 'preparation'
+dependency 'snoopy'
+dependency 'zlib'
+EOH
+    project = Omnibus::Project.new(raw_project, 'demo.rb')
+    project
+  end
+
+  let(:fake_software_config_file) do
+    File.join(Omnibus::RSpec::SPEC_DATA, 'software', 'zlib.rb')
+  end
+
+  let(:zlib) do
+    software = Omnibus::Software.new('', fake_software_config_file, project)
+    software.name('zlib')
+    software.default_version('1.7.2')
+    software
+  end
+
+  let(:snoopy) do
+    software = Omnibus::Software.new('', 'snoopy.rb', project)
+    software.name('snoopy')
+    software.default_version('1.0.0')
+    software
+  end
+
+  let(:preparation) do
+    software = Omnibus::Software.new('', 'preparation.rb', project)
+    software.name('preparation')
+    software.default_version('1.0.0')
+    software
+  end
+
+  let(:cache_path) { "/var/cache/omnibus/cache/install_path#{install_path}" }
+
+  let(:ipc) do
+    project.library.component_added(preparation)
+    project.library.component_added(snoopy)
+    project.library.component_added(zlib)
+    Omnibus::InstallPathCache.new(install_path, zlib)
+  end
+
+  describe '#cache_path' do
+    it 'returns the install path appended to the install_cache path' do
+      expect(ipc.cache_path).to eq('/var/cache/omnibus/cache/install_path/opt/chef')
+    end
+  end
+
+  describe '#cache_path_exists?' do
+    it 'checks for existence' do
+      expect(File).to receive(:directory?).with(ipc.cache_path)
+      ipc.cache_path_exists?
+    end
+  end
+
+  describe '#tag' do
+    # 13b3f7f2653e40b9d5b393659210775ac5b56f7e0009f82f85b83f5132409362
+    #
+    # Is the sha256sum of:
+    # cat spec/data/software/zlib.rb > t
+    # echo -n 'preparation-1.0.0-snoopy-1.0.0' >> t
+    # sha256sum t
+    it 'returns a tag with the softwares name, version, and hash of deps name+version' do
+      expect(ipc.tag).to eql('zlib-1.7.2-13b3f7f2653e40b9d5b393659210775ac5b56f7e0009f82f85b83f5132409362')
+    end
+
+    describe 'with no deps' do
+      let(:ipc) do
+        Omnibus::InstallPathCache.new(install_path, zlib)
+      end
+
+      it 'uses the shasum of the software config file' do
+        # gsha256sum spec/data/software/zlib.rb
+        # 363e6cc2475fcdd6e18b2dc10f6022d1cab498b9961e8225d8a309d18ed3c94b  spec/data/software/zlib.rb
+        expect(ipc.tag).to eql('zlib-1.7.2-363e6cc2475fcdd6e18b2dc10f6022d1cab498b9961e8225d8a309d18ed3c94b')
+      end
+    end
+  end
+
+  describe '#create_cache_path' do
+    it 'runs git init if the cache path does not exist' do
+      allow(File).to receive(:directory?).with(ipc.cache_path).and_return(false)
+      allow(File).to receive(:directory?).with(File.dirname(ipc.cache_path)).and_return(false)
+      expect(FileUtils).to receive(:mkdir_p).with(File.dirname(ipc.cache_path))
+      expect(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} init -q")
+      ipc.create_cache_path
+    end
+
+    it 'does not run git init if the cache path exists' do
+      allow(File).to receive(:directory?).with(ipc.cache_path).and_return(true)
+      allow(File).to receive(:directory?).with(File.dirname(ipc.cache_path)).and_return(true)
+      expect(ipc).to_not receive(:shellout!).with("git --git-dir=#{cache_path} init -q")
+      ipc.create_cache_path
+    end
+  end
+
+  describe '#incremental' do
+    before(:each) do
+      allow(ipc).to receive(:shellout!)
+      allow(ipc).to receive(:create_cache_path)
+    end
+
+    it 'creates the cache path' do
+      expect(ipc).to receive(:create_cache_path)
+      ipc.incremental
+    end
+
+    it 'adds all the changes to git' do
+      expect(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} add -A -f")
+      ipc.incremental
+    end
+
+    it 'commits the backup for the software' do
+      expect(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} commit -q -m 'Backup of #{ipc.tag}'")
+      ipc.incremental
+    end
+
+    it 'tags the software backup' do
+      expect(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} tag -f '#{ipc.tag}'")
+      ipc.incremental
+    end
+  end
+
+  describe '#restore' do
+    let(:git_tag_output) { "#{ipc.tag}\n" }
+
+    let(:tag_cmd) do
+      cmd_double = double(Mixlib::ShellOut)
+      allow(cmd_double).to receive(:stdout).and_return(git_tag_output)
+      allow(cmd_double).to receive(:error!).and_return(cmd_double)
+      cmd_double
+    end
+
+    before(:each) do
+      allow(ipc).to receive(:shellout).with("git --git-dir=#{cache_path} --work-tree=#{install_path} tag -l #{ipc.tag}").and_return(tag_cmd)
+      allow(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} checkout -f '#{ipc.tag}'")
+      allow(ipc).to receive(:create_cache_path)
+    end
+
+    it 'creates the cache path' do
+      expect(ipc).to receive(:create_cache_path)
+      ipc.restore
+    end
+
+    it 'checks for a tag with the software and version, and if it finds it, checks it out' do
+      expect(ipc).to receive(:shellout).with("git --git-dir=#{cache_path} --work-tree=#{install_path} tag -l #{ipc.tag}").and_return(tag_cmd)
+      expect(ipc).to receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} checkout -f '#{ipc.tag}'")
+      ipc.restore
+    end
+
+    describe 'if the tag does not exist' do
+      let(:git_tag_output) { "\n" }
+
+      it 'does nothing' do
+        expect(ipc).to receive(:shellout).with("git --git-dir=#{cache_path} --work-tree=#{install_path} tag -l #{ipc.tag}").and_return(tag_cmd)
+        expect(ipc).to_not receive(:shellout!).with("git --git-dir=#{cache_path} --work-tree=#{install_path} checkout -f '#{ipc.tag}'")
+        ipc.restore
+      end
+    end
+  end
+end

data/spec/unit/library_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'omnibus/library'
+require 'omnibus/project'
+
+describe Omnibus::Library do
+  let(:project) { Omnibus::Project.load(project_path('chefdk')) }
+  let(:library) { Omnibus::Library.new(project) }
+  let(:erchef) { Omnibus::Software.load(software_path('erchef'), project) }
+  let(:zlib) { Omnibus::Software.load(software_path('zlib'), project) }
+
+  describe '#component_added' do
+    it 'adds the software to the component list' do
+      library.component_added(erchef)
+      expect(library.components).to eql([erchef])
+    end
+
+    it 'does not add a component more than once' do
+      library.component_added(erchef)
+      library.component_added(erchef)
+      expect(library.components).to eql([erchef])
+    end
+  end
+
+  describe '#build_order' do
+    let(:project) do
+      raw_project = <<-EOH
+name "chef-server"
+install_path "/opt/chef-server"
+build_version "1.0.0"
+maintainer 'Chef Software, Inc'
+homepage 'http://getchef.com'
+dependency 'preparation'
+dependency 'erchef'
+dependency 'chef'
+EOH
+      Omnibus::Project.new(raw_project, 'chef-server.rb')
+    end
+
+    let(:library) do
+      library = Omnibus::Library.new(project)
+      library.component_added(preparation)
+      library.component_added(erlang)
+      library.component_added(skitch)
+      library.component_added(erchef)
+      library.component_added(ruby)
+      library.component_added(chef)
+      library
+    end
+
+    project_deps = [:preparation, :erchef, :chef]
+    erchef_deps = [:erlang, :skitch]
+    chef_deps = [:ruby]
+
+    [project_deps, erchef_deps, chef_deps].flatten.each do |dep|
+      let(dep) do
+        software = Omnibus::Software.new('', "#{dep}.rb", 'chef-server')
+        software.name(dep.to_s)
+        software
+      end
+    end
+
+    it 'returns an array of software descriptions, with all non top level deps first' do
+      expect(library.build_order).to eql([preparation, erlang, skitch, ruby, erchef, chef])
+    end
+  end
+
+end

data/spec/unit/packagers/base_spec.rb

@@ -0,0 +1,221 @@
+#
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Omnibus
+  describe Packager::Base do
+    let(:project) do
+      double('project',
+             name: 'hamlet',
+             build_version: '1.0.0',
+             iteration: '12902349',
+             mac_pkg_identifier: 'com.chef.hamlet',
+             install_path: '/opt/hamlet',
+             package_scripts_path: 'package-scripts',
+             files_path: 'files',
+             package_dir: 'pkg',
+             package_tmp: 'pkg-tmp',
+      )
+    end
+
+    subject { described_class.new(project) }
+
+    it 'includes Util' do
+      expect(subject).to be_a(Util)
+    end
+
+    it 'delegates #name to @project' do
+      expect(subject.name).to eq(project.name)
+    end
+
+    it 'delegates #version to @project' do
+      expect(subject.version).to eq(project.build_version)
+    end
+
+    it 'delegates #iteration to @project' do
+      expect(subject.iteration).to eq(project.iteration)
+    end
+
+    it 'delegates #identifer to @project' do
+      expect(subject.identifier).to eq(project.mac_pkg_identifier)
+    end
+
+    it 'delegates #scripts to @project' do
+      expect(subject.scripts).to eq(project.package_scripts_path)
+    end
+
+    it 'delegates #files_path to @project' do
+      expect(subject.files_path).to eq(project.files_path)
+    end
+
+    it 'delegates #package_dir to @project' do
+      expect(subject.package_dir).to eq(project.package_dir)
+    end
+
+    describe '.setup' do
+      it 'sets the value of the block' do
+        block = proc {}
+        described_class.setup(&block)
+
+        expect(described_class.setup).to eq(block)
+      end
+    end
+
+    describe '.validate' do
+      it 'sets the value of the block' do
+        block = proc {}
+        described_class.validate(&block)
+
+        expect(described_class.validate).to eq(block)
+      end
+    end
+
+    describe '.build' do
+      it 'sets the value of the block' do
+        block = proc {}
+        described_class.build(&block)
+
+        expect(described_class.build).to eq(block)
+      end
+
+      it 'is a required phase' do
+        described_class.instance_variable_set(:@build, nil)
+        expect { described_class.build }.to raise_error(AbstractMethod)
+      end
+    end
+
+    describe '.clean' do
+      it 'sets the value of the block' do
+        block = proc {}
+        described_class.clean(&block)
+
+        expect(described_class.clean).to eq(block)
+      end
+    end
+
+    describe '#create_directory' do
+      before { FileUtils.stub(:mkdir_p) }
+
+      it 'creates the directory' do
+        expect(FileUtils).to receive(:mkdir_p).with('/foo/bar')
+        subject.create_directory('/foo/bar')
+      end
+
+      it 'returns the path' do
+        expect(subject.create_directory('/foo/bar')).to eq('/foo/bar')
+      end
+    end
+
+    describe '#remove_directory' do
+      before { FileUtils.stub(:rm_rf) }
+
+      it 'remove the directory' do
+        expect(FileUtils).to receive(:rm_rf).with('/foo/bar')
+        subject.remove_directory('/foo/bar')
+      end
+    end
+
+    describe '#purge_directory' do
+      before do
+        subject.stub(:remove_directory)
+        subject.stub(:create_directory)
+      end
+
+      it 'removes and creates the directory' do
+        expect(subject).to receive(:remove_directory).with('/foo/bar')
+        expect(subject).to receive(:create_directory).with('/foo/bar')
+        subject.purge_directory('/foo/bar')
+      end
+    end
+
+    describe '#copy_file' do
+      before { FileUtils.stub(:cp) }
+
+      it 'copies the file' do
+        expect(FileUtils).to receive(:cp).with('foo', 'bar')
+        subject.copy_file('foo', 'bar')
+      end
+
+      it 'returns the destination path' do
+        expect(subject.copy_file('foo', 'bar')).to eq('bar')
+      end
+    end
+
+    describe '#remove_file' do
+      before { FileUtils.stub(:rm_f) }
+
+      it 'removes the file' do
+        expect(FileUtils).to receive(:rm_f).with('/foo/bar')
+        subject.remove_file('/foo/bar')
+      end
+    end
+
+    describe '#execute' do
+      before { subject.stub(:shellout!) }
+
+      it 'shellsout' do
+        expect(subject).to receive(:shellout!)
+          .with('echo "hello"', timeout: 3600, cwd: anything)
+        subject.execute('echo "hello"')
+      end
+    end
+
+    describe '#assert_presence!' do
+      it 'raises a MissingAsset exception when the file does not exist' do
+        File.stub(:exist?).and_return(false)
+        expect { subject.assert_presence!('foo') }.to raise_error(MissingAsset)
+      end
+    end
+
+    describe '#run!' do
+      before do
+        described_class.stub(:validate).and_return(proc {})
+        described_class.stub(:setup).and_return(proc {})
+        described_class.stub(:build).and_return(proc {})
+        described_class.stub(:clean).and_return(proc {})
+      end
+
+      it 'calls the methods in order' do
+        expect(described_class).to receive(:validate).ordered
+        expect(described_class).to receive(:setup).ordered
+        expect(described_class).to receive(:build).ordered
+        expect(described_class).to receive(:clean).ordered
+        subject.run!
+      end
+    end
+
+    describe '#staging_dir' do
+      it 'is the project package tmp and underscored named' do
+        name = "#{project.package_tmp}/base"
+        expect(subject.send(:staging_dir)).to eq(File.expand_path(name))
+      end
+    end
+
+    describe '#resource' do
+      it 'prefixes to the resources_path' do
+        path = 'files/base/Resources/icon.png'
+        expect(subject.send(:resource, 'icon.png')).to eq(File.expand_path(path))
+      end
+    end
+
+    describe '#resoures_path' do
+      it 'is the files_path, underscored_name, and Resources' do
+        path = "#{project.files_path}/base/Resources"
+        expect(subject.send(:resources_path)).to eq(File.expand_path(path))
+      end
+    end
+  end
+end