omnibus 1.3.0 → 2.0.0.rc1

data/spec/package_release_spec.rb

@@ -1,5 +1,5 @@
 #
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# Copyright:: Copyright (c) 2012-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,75 +19,75 @@ require 'omnibus/package_release'
 require 'spec_helper'
 
 describe Omnibus::PackageRelease do
-  let(:s3_key) { "s3key" }
-  let(:s3_secret) { "hey-bezos-store-my-stuff" }
-  let(:s3_bucket) { "myorg-omnibus-packages" }
-  let(:pkg_path) { "pkg/chef_11.4.0-183-g2c0040c-0.el6.x86_64.rpm" }
+  let(:s3_key) { 's3key' }
+  let(:s3_secret) { 'hey-bezos-store-my-stuff' }
+  let(:s3_bucket) { 'myorg-omnibus-packages' }
+  let(:pkg_path) { 'pkg/chef_11.4.0-183-g2c0040c-0.el6.x86_64.rpm' }
   let(:pkg_metadata_path) { "#{pkg_path}.metadata.json" }
 
   let(:config) do
     {
-      :release_s3_access_key => s3_key,
-      :release_s3_secret_key => s3_secret,
-      :release_s3_bucket => s3_bucket
+      release_s3_access_key: s3_key,
+      release_s3_secret_key: s3_secret,
+      release_s3_bucket: s3_bucket,
     }
   end
   subject(:package_release) do
     Omnibus::PackageRelease.new(pkg_path)
   end
 
-  it "has a package path" do
-    package_release.package_path.should == pkg_path
+  it 'has a package path' do
+    expect(package_release.package_path).to eq(pkg_path)
   end
 
   it "defaults to `:private' access policy" do
-    package_release.access_policy.should == :private
+    expect(package_release.access_policy).to eq(:private)
   end
 
-  describe "validating configuration" do
+  describe 'validating configuration' do
 
     before do
       Omnibus.stub(:config).and_return(config)
     end
 
-    it "validates that the s3 key is set" do
+    it 'validates that the s3 key is set' do
       config.delete(:release_s3_access_key)
-      lambda { package_release.validate_config! }.should raise_error(Omnibus::InvalidS3ReleaseConfiguration)
+      expect { package_release.validate_config! }.to raise_error(Omnibus::InvalidS3ReleaseConfiguration)
     end
 
-    it "validates that the s3 secret key is set" do
+    it 'validates that the s3 secret key is set' do
       config.delete(:release_s3_secret_key)
-      lambda { package_release.validate_config! }.should raise_error(Omnibus::InvalidS3ReleaseConfiguration)
+      expect { package_release.validate_config! }.to raise_error(Omnibus::InvalidS3ReleaseConfiguration)
     end
 
-    it "validates that the s3 bucket is set" do
+    it 'validates that the s3 bucket is set' do
       config.delete(:release_s3_bucket)
-      lambda { package_release.validate_config! }.should raise_error(Omnibus::InvalidS3ReleaseConfiguration)
+      expect { package_release.validate_config! }.to raise_error(Omnibus::InvalidS3ReleaseConfiguration)
     end
 
-    it "does not error on a valid configuration" do
-      lambda { package_release.validate_config! }.should_not raise_error
+    it 'does not error on a valid configuration' do
+      expect { package_release.validate_config! }.to_not raise_error
     end
   end
 
-  describe "validating package for upload" do
-    it "ensures that the package file exists" do
-      lambda { package_release.validate_package! }.should raise_error(Omnibus::NoPackageFile)
+  describe 'validating package for upload' do
+    it 'ensures that the package file exists' do
+      expect { package_release.validate_package! }.to raise_error(Omnibus::NoPackageFile)
     end
 
-    it "ensures that there is a metadata file for the package" do
-      File.should_receive(:exist?).with(pkg_path).and_return(true)
-      File.should_receive(:exist?).with(pkg_metadata_path).and_return(false)
-      lambda { package_release.validate_package! }.should raise_error(Omnibus::NoPackageMetadataFile)
+    it 'ensures that there is a metadata file for the package' do
+      expect(File).to receive(:exist?).with(pkg_path).and_return(true)
+      expect(File).to receive(:exist?).with(pkg_metadata_path).and_return(false)
+      expect { package_release.validate_package! }.to raise_error(Omnibus::NoPackageMetadataFile)
     end
   end
 
-  context "with a valid config and package" do
+  context 'with a valid config and package' do
 
-    let(:basename) { "chef_11.4.0-183-g2c0040c-0.el6.x86_64.rpm" }
-    let(:md5) { "016f2e0854c69901b3f0ad8f99ffdb75" }
-    let(:platform_path) { "el/6/x86_64" }
-    let(:pkg_content) { "expected package content" }
+    let(:basename) { 'chef_11.4.0-183-g2c0040c-0.el6.x86_64.rpm' }
+    let(:md5) { '016f2e0854c69901b3f0ad8f99ffdb75' }
+    let(:platform_path) { 'el/6/x86_64' }
+    let(:pkg_content) { 'expected package content' }
 
     let(:metadata_json) do
       <<-E
@@ -111,38 +111,37 @@ describe Omnibus::PackageRelease do
       IO.stub(:read).with(pkg_path).and_return(pkg_content)
     end
 
-    it "configures s3 with the given credentials" do
+    it 'configures s3 with the given credentials' do
       expected_s3_config = {
-        :access_key         => s3_key,
-        :secret_access_key  => s3_secret,
-        :bucket             => s3_bucket,
-        :adaper             => :net_http
+        access_key: s3_key,
+        secret_access_key: s3_secret,
+        bucket: s3_bucket,
+        adaper: :net_http,
       }
-      UberS3.should_receive(:new).with(expected_s3_config)
+      expect(UberS3).to receive(:new).with(expected_s3_config)
       package_release.s3_client
     end
 
-    it "generates the relative path for the package s3 key" do
-      package_release.platform_path.should == platform_path
+    it 'generates the relative path for the package s3 key' do
+      expect(package_release.platform_path).to eq(platform_path)
     end
 
-
-    it "uploads the package and metadata" do
-      package_release.s3_client.should_receive(:store).with(
+    it 'uploads the package and metadata' do
+      expect(package_release.s3_client).to receive(:store).with(
         "#{platform_path}/#{basename}.metadata.json",
         metadata_json,
-        :access => :private
+        access: :private,
       )
-      package_release.s3_client.should_receive(:store).with(
+      expect(package_release.s3_client).to receive(:store).with(
         "#{platform_path}/#{basename}",
         pkg_content,
-        :access => :private,
-        :content_md5 => md5
+        access: :private,
+        content_md5: md5,
       )
       package_release.release
     end
 
-    context "and a callback is given for after upload" do
+    context 'and a callback is given for after upload' do
       let(:upload_records) { [] }
 
       subject(:package_release) do
@@ -151,42 +150,44 @@ describe Omnibus::PackageRelease do
         end
       end
 
-      it "fires the after_upload callback for each item uploaded" do
-        package_release.s3_client.should_receive(:store).with(
+      it 'fires the after_upload callback for each item uploaded' do
+        expect(package_release.s3_client).to receive(:store).with(
           "#{platform_path}/#{basename}.metadata.json",
           metadata_json,
-          :access => :private
+          access: :private,
         )
-        package_release.s3_client.should_receive(:store).with(
+        expect(package_release.s3_client).to receive(:store).with(
           "#{platform_path}/#{basename}",
           pkg_content,
-          :access => :private,
-          :content_md5 => md5
+          access: :private,
+          content_md5: md5,
         )
         package_release.release
 
-        upload_records.should == [ "#{platform_path}/#{basename}.metadata.json",
-                                   "#{platform_path}/#{basename}" ]
+        expect(upload_records).to eq [
+          "#{platform_path}/#{basename}.metadata.json",
+          "#{platform_path}/#{basename}",
+        ]
       end
     end
 
-    context "and the package is public" do
+    context 'and the package is public' do
 
       subject(:package_release) do
-        Omnibus::PackageRelease.new(pkg_path, :access => :public_read)
+        Omnibus::PackageRelease.new(pkg_path, access: :public_read)
       end
 
-      it "uploads the package and metadata" do
-        package_release.s3_client.should_receive(:store).with(
+      it 'uploads the package and metadata' do
+        expect(package_release.s3_client).to receive(:store).with(
           "#{platform_path}/#{basename}.metadata.json",
           metadata_json,
-          :access => :public_read
+          access: :public_read,
         )
-        package_release.s3_client.should_receive(:store).with(
+        expect(package_release.s3_client).to receive(:store).with(
           "#{platform_path}/#{basename}",
           pkg_content,
-          :access => :public_read,
-          :content_md5 => md5
+          access: :public_read,
+          content_md5: md5,
         )
         package_release.release
       end

data/spec/packagers/mac_pkg_spec.rb

@@ -0,0 +1,261 @@
+#
+# 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.
+#
+
+require 'stringio'
+require 'omnibus/packagers/mac_pkg'
+require 'spec_helper'
+
+describe Omnibus::Packagers::MacPkg do
+
+  let(:project_name) { 'myproject' }
+
+  let(:mac_pkg_identifier) { 'com.mycorp.myproject' }
+
+  let(:omnibus_root) { '/omnibus/project/root' }
+
+  let(:scripts_path) { "#{omnibus_root}/scripts" }
+
+  let(:package_dir) { '/home/someuser/omnibus-myproject/pkg' }
+
+  let(:package_tmp) { '/var/cache/omnibus/pkg-tmp' }
+
+  let(:files_path) { "#{omnibus_root}/files" }
+
+  let(:expected_distribution_content) do
+    <<-EOH
+<?xml version="1.0" standalone="no"?>
+<installer-gui-script minSpecVersion="1">
+    <title>Myproject</title>
+    <background file="background.png" alignment="bottomleft" mime-type="image/png"/>
+    <welcome file="welcome.html" mime-type="text/html"/>
+    <license file="license.html" mime-type="text/html"/>
+
+    <!-- Generated by productbuild - - synthesize -->
+    <pkg-ref id="com.mycorp.myproject"/>
+    <options customize="never" require-scripts="false"/>
+    <choices-outline>
+        <line choice="default">
+            <line choice="com.mycorp.myproject"/>
+        </line>
+    </choices-outline>
+    <choice id="default"/>
+    <choice id="com.mycorp.myproject" visible="false">
+        <pkg-ref id="com.mycorp.myproject"/>
+    </choice>
+    <pkg-ref id="com.mycorp.myproject" version="23.4.2" onConclusion="none">myproject-core.pkg</pkg-ref>
+</installer-gui-script>
+EOH
+  end
+
+  let(:expected_distribution_path) { '/var/cache/omnibus/pkg-tmp/mac-pkg/Distribution' }
+
+  let(:productbuild_argv) do
+    %W[
+      productbuild
+      --distribution #{expected_distribution_path}
+      --resources /omnibus/project/root/files/mac_pkg/Resources
+      /home/someuser/omnibus-myproject/pkg/myproject.pkg
+    ]
+  end
+
+  let(:pkgbuild_argv) do
+    %w[
+      pkgbuild
+      --identifier com.mycorp.myproject
+      --version 23.4.2
+      --scripts /omnibus/project/root/scripts
+      --root /opt/myproject
+      --install-location /opt/myproject
+      myproject-core.pkg
+    ]
+  end
+
+  let(:shellout_opts) do
+    {
+      timeout: 3600,
+      cwd: File.join(package_tmp, 'mac-pkg'),
+    }
+  end
+
+  let(:project) do
+    double Omnibus::Project,
+           name: project_name,
+           build_version: '23.4.2',
+           maintainer: "Joe's Software",
+           install_path: '/opt/myproject',
+           package_scripts_path: scripts_path,
+           files_path: files_path,
+           package_dir: package_dir,
+           package_tmp: package_tmp,
+           mac_pkg_identifier: mac_pkg_identifier
+  end
+
+  let(:packager) do
+    Omnibus::Packagers::MacPkg.new(project)
+  end
+
+  it "uses the project's version" do
+    expect(packager.version).to eq(project.build_version)
+  end
+
+  it "uses the project's name" do
+    expect(packager.name).to eq(project.name)
+  end
+
+  it "uses the project's mac_pkg_identifier" do
+    expect(packager.identifier).to eq(mac_pkg_identifier)
+  end
+
+  it "uses the project's install_path as the package root" do
+    expect(packager.pkg_root).to eq(project.install_path)
+  end
+
+  it "uses the project's install_path as the package install location" do
+    expect(packager.install_location).to eq(project.install_path)
+  end
+
+  it 'names the component package PROJECT_NAME-core.pkg' do
+    expect(packager.component_pkg_name).to eq('myproject-core.pkg')
+  end
+
+  it 'names the product package PROJECT_NAME.pkg' do
+    # NOTE: #package_name is used by Project, so it's part of the **PUBLIC**
+    # API.
+    expect(packager.package_name).to eq('myproject.pkg')
+    expect(packager.product_pkg_name).to eq('myproject.pkg')
+  end
+
+  it "use's the project's package_scripts_path" do
+    expect(packager.scripts).to eq(project.package_scripts_path)
+  end
+
+  it "makes a list of required files to generate the 'product' pkg file" do
+    project_file_path = '/omnibus/project/root/files/mac_pkg/Resources'
+    required_files = %w[background.png welcome.html license.html].map do |basename|
+      File.join(project_file_path, basename)
+    end
+
+    expect(packager.required_files).to match_array(required_files)
+  end
+
+  it 'validates that all required files are present' do
+    expected_error_text = <<-E
+      Your omnibus repo is missing the following files required to build Mac
+      packages:
+      * /omnibus/project/root/files/mac_pkg/Resources/background.png
+      * /omnibus/project/root/files/mac_pkg/Resources/license.html
+      * /omnibus/project/root/files/mac_pkg/Resources/welcome.html
+E
+    # RSpec 2.14.1 doesn't do nice diffs of expected error strings, so do this
+    # the hard way for now.
+    e = nil
+    begin
+      packager.validate_omnibus_project!
+    rescue => e
+    end
+    expect(e).to be_a(Omnibus::MissingMacPkgResource)
+    expect(e.to_s).to eq(expected_error_text)
+  end
+
+  it 'clears and recreates the staging dir' do
+    expect(FileUtils).to receive(:rm_rf).with('/var/cache/omnibus/pkg-tmp/mac-pkg')
+    expect(FileUtils).to receive(:mkdir_p).with('/var/cache/omnibus/pkg-tmp/mac-pkg')
+    packager.setup_staging_dir!
+  end
+
+  it 'generates a pkgbuild command' do
+    expect(packager.pkgbuild_command).to eq(pkgbuild_argv)
+  end
+
+  it 'runs pkgbuild' do
+    expected_args = pkgbuild_argv + [shellout_opts]
+    expect(packager).to receive(:shellout!).with(*expected_args)
+    packager.build_component_pkg
+  end
+
+  it 'has a temporary staging location for the distribution file' do
+    expect(packager.staging_dir).to eq('/var/cache/omnibus/pkg-tmp/mac-pkg')
+  end
+
+  it 'generates a Distribution file describing the product package content' do
+    expect(packager.distribution).to eq(expected_distribution_content)
+  end
+
+  it 'generates a productbuild command' do
+    expect(packager.productbuild_command).to eq(productbuild_argv)
+  end
+
+  describe 'building the product package' do
+
+    let(:distribution_file) { StringIO.new }
+
+    before do
+      expect(File).to receive(:open)
+        .with(expected_distribution_path, File::RDWR | File::CREAT | File::EXCL, 0600)
+        .and_yield(distribution_file)
+    end
+
+    it 'writes the distribution file to the staging directory' do
+      packager.generate_distribution
+      expect(distribution_file.string).to eq(expected_distribution_content)
+    end
+
+    it 'generates the distribution and runs productbuild' do
+      expected_shellout_args = productbuild_argv + [shellout_opts]
+
+      expect(packager).to receive(:shellout!).with(*expected_shellout_args)
+      packager.build_product_pkg
+      expect(distribution_file.string).to eq(expected_distribution_content)
+    end
+
+  end
+  context "when the mac_pkg_identifier isn't specified by the project" do
+
+    let(:mac_pkg_identifier) { nil }
+    let(:project_name) { 'My $Project' }
+
+    it 'sanitizes the MAINTAINER name' do
+      expect(packager.sanitized_maintainer).to eq('joessoftware')
+    end
+
+    it 'sanitizes the project name' do
+      expect(packager.sanitized_name).to eq('myproject')
+    end
+
+    it 'uses com.example.PROJECT_NAME as the identifier' do
+      expect(packager.identifier).to eq('test.joessoftware.pkg.myproject')
+    end
+
+  end
+
+  context 'when the project has the required Resource files' do
+
+    before do
+      project_file_path = '/omnibus/project/root/files/mac_pkg/Resources'
+      %w[background.png welcome.html license.html].each do |basename|
+        path = File.join(project_file_path, basename)
+        File.stub(:exist?).with(path).and_return(true)
+      end
+    end
+
+    it 'validates the presence of the required files' do
+      expect(packager.validate_omnibus_project!).to be_true
+    end
+
+  end
+
+end

data/spec/project_spec.rb

@@ -0,0 +1,138 @@
+#
+# Copyright:: Copyright (c) 2014 Noah Kantrowitz
+# 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.
+#
+
+require 'spec_helper'
+
+require 'omnibus/project'
+
+describe Omnibus::Project do
+  let(:project) do
+    Omnibus::Project.load(project_path('sample'))
+  end
+
+  subject { project }
+
+  describe 'basics' do
+    it 'should return a name' do
+      expect(project.name).to eq('sample')
+    end
+
+    it 'should return an install path' do
+      expect(project.install_path).to eq('/sample')
+    end
+
+    it 'should return a maintainer' do
+      expect(project.maintainer).to eq('Sample Devs')
+    end
+
+    it 'should return a homepage' do
+      expect(project.homepage).to eq('http://example.com/')
+    end
+
+    it 'should return a build version' do
+      expect(project.build_version).to eq('1.0')
+    end
+
+    it 'should return a build iteration' do
+      expect(project.build_iteration).to eq('1')
+    end
+
+    it 'should return an array of files and dirs' do
+      expect(project.extra_package_files).to eq(['/path/to/sample_dir', '/path/to/file.conf'])
+    end
+  end
+
+  describe '#iteration' do
+    let(:fauxhai_options) { Hash.new }
+    around(:each) do |example|
+      data = OHAI.data
+      begin
+        OHAI.data = Mash.new(Fauxhai.mock(fauxhai_options).data)
+        example.run
+      ensure
+        OHAI.data = data
+      end
+    end
+
+    context 'when on RHEL' do
+      let(:fauxhai_options) { { platform: 'redhat', version: '6.4' } }
+      it 'should return a RHEL iteration' do
+        expect(project.iteration).to eq('1.el6')
+      end
+    end
+
+    context 'when on Debian' do
+      let(:fauxhai_options) { { platform: 'debian', version: '7.2' } }
+      it 'should return a Debian iteration' do
+        expect(project.iteration).to eq('1')
+      end
+    end
+
+    context 'when on FreeBSD' do
+      let(:fauxhai_options) { { platform: 'freebsd', version: '9.1' } }
+      it 'should return a FreeBSD iteration' do
+        expect(project.iteration).to eq('1.freebsd.9.amd64')
+      end
+    end
+
+    context 'when on Windows' do
+      let(:fauxhai_options) { { platform: 'windows', version: '2008R2' } }
+      it 'should return a Windows iteration' do
+        expect(project.iteration).to eq('1.windows')
+      end
+    end
+
+    context 'when on OS X' do
+      let(:fauxhai_options) { { platform: 'mac_os_x', version: '10.8.2' } }
+      it 'should return a generic iteration' do
+        expect(project.iteration).to eq('1.mac_os_x.10.8.2')
+      end
+    end
+  end
+
+  describe '#overrides' do
+    let(:project) { Omnibus::Project.load(project_path('chefdk')) }
+
+    it 'should set an override for the zlib version' do
+      expect(project.overrides[:zlib][:version]).to eq('1.2.8')
+    end
+
+    it 'should access the zlib version through the #override method as well' do
+      expect(project.override(:zlib)[:version]).to eq('1.2.8')
+    end
+
+    it 'should set all the things through #overrides' do
+      project.overrides(thing: { version: '6.6.6' })
+      expect(project.override(:zlib)).to be_nil
+    end
+
+    it 'should retrieve the things set through #overrides' do
+      project.overrides(thing: { version: '6.6.6' })
+      expect(project.override(:thing)[:version]).to eq('6.6.6')
+    end
+
+    it 'should not set other things through setting a single #override' do
+      project.override(:thing, version: '6.6.6')
+      expect(project.override(:zlib)[:version]).to eq('1.2.8')
+    end
+
+    it 'should retrieve the things set through #overrides' do
+      project.override(:thing, version: '6.6.6')
+      expect(project.override(:thing)[:version]).to eq('6.6.6')
+    end
+  end
+end

data/spec/s3_cacher_spec.rb

@@ -1,5 +1,5 @@
 #
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Copyright:: Copyright (c) 2013-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,22 +26,21 @@ describe Omnibus::S3Cache do
     let(:source_a) { double(source: { url: 'a' }) }
     let(:source_b) { double(source: { url: 'b' }) }
     let(:source_c) { double(source: {}) }
-    let(:projects) { [
-      double({ library: [source_a, source_c] }),
-      double({ library: [source_c, source_b] })
-    ] }
+    let(:projects) do
+      [
+        double(library: [source_a, source_c]),
+        double(library: [source_c, source_b]),
+      ]
+    end
     let(:software_with_urls) { [source_a, source_b] }
 
     before do
-      Omnibus.stub(config: double({
-        s3_bucket: 'test', s3_access_key: 'test', s3_secret_key: 'test'
-      }))
-
+      Omnibus.stub(config: double(s3_bucket: 'test', s3_access_key: 'test', s3_secret_key: 'test'))
       Omnibus.stub(projects: projects)
     end
 
     it 'lists all software with urls' do
-      tarball_software.should == software_with_urls
+      expect(tarball_software).to eq(software_with_urls)
     end
   end
 end