omnibus 3.1.1 → 3.2.0.rc.1

data/spec/unit/ohai_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Omnibus
+  describe Ohai do
+    context 'using dot notation' do
+      it 'does not raise an exception' do
+        expect { Ohai.kernel }.to_not raise_error
+        expect { Ohai.kernel.machine }.to_not raise_error
+      end
+    end
+
+    context 'using hash notation' do
+      it 'allows fetching values by hash notation' do
+        expect { Ohai['kernel'] }.to_not raise_error
+        expect { Ohai['kernel']['machine'] }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/unit/omnibus_spec.rb

@@ -2,62 +2,64 @@ require 'omnibus'
 require 'spec_helper'
 
 describe Omnibus do
-  # evil class variables
-  before { Omnibus.reset! }
-  after  { Omnibus.reset! }
-
-  describe '::omnibus_software_root' do
-    it 'reads the software_gem out of Omnibus::Config.software_gem' do
-      spec_array = [double(Gem::Specification, gem_dir: '/data')]
-      expect(Omnibus::Config).to receive(:software_gem)
-        .and_return('my-omnibus-software-gem')
-      expect(Gem::Specification).to receive(:find_all_by_name)
-        .with('my-omnibus-software-gem')
-        .and_return(spec_array)
-
-      Omnibus.omnibus_software_root
-    end
+  before do
+    allow(File).to receive(:directory?).and_return(true)
 
-    it 'uses the omnibus-software gem as the default' do
-      spec_array = [double(Gem::Specification, gem_dir: '/data')]
-      expect(Gem::Specification).to receive(:find_all_by_name)
-        .with('omnibus-software')
-        .and_return(spec_array)
+    allow(Gem::Specification).to receive(:find_all_by_name)
+      .with('omnibus-software')
+      .and_return([double(gem_dir: '/gem/omnibus-software')])
 
-      Omnibus.omnibus_software_root
-    end
+    allow(Gem::Specification).to receive(:find_all_by_name)
+      .with('custom-omnibus-software')
+      .and_return([double(gem_dir: '/gem/custom-omnibus-software')])
+
+    Omnibus::Config.project_root('/foo/bar')
+    Omnibus::Config.local_software_dirs(['/local', '/other'])
+    Omnibus::Config.software_gems(['omnibus-software', 'custom-omnibus-software'])
   end
 
   describe '#software_dirs' do
-    context 'omnibus_software_root not nil' do
-      before do
-        Omnibus.stub(:omnibus_software_root) { './data' }
-      end
-
-      it 'will include list of software from omnibus-software gem' do
-        expect(Omnibus.software_dirs.length).to eq(2)
-      end
+    let(:software_dirs) { Omnibus.software_dirs }
+
+    it 'includes project_root' do
+      expect(software_dirs).to include('/foo/bar/config/software')
+    end
+
+    it 'includes local_software_dirs dirs' do
+      expect(software_dirs).to include('/local/config/software')
+      expect(software_dirs).to include('/other/config/software')
     end
 
-    context 'omnibus_software_root nil' do
-      before do
-        Omnibus.stub(:omnibus_software_root) { nil }
-      end
+    it 'includes software_gems dirs' do
+      expect(software_dirs).to include('/gem/omnibus-software/config/software')
+      expect(software_dirs).to include('/gem/custom-omnibus-software/config/software')
+    end
+
+    it 'has the correct precedence order' do
+      expect(software_dirs).to eq([
+        '/foo/bar/config/software',
+        '/local/config/software',
+        '/other/config/software',
+        '/gem/omnibus-software/config/software',
+        '/gem/custom-omnibus-software/config/software',
+      ])
+    end
+  end
+
+  describe '#software_map' do
+    let(:software_map) { Omnibus.send(:software_map) }
 
-      it 'will not include list of software from omnibus-software gem' do
-        expect(Omnibus.software_dirs.length).to eq(1)
-      end
+    it 'returns a hash' do
+      expect(software_map).to be_a(Hash)
     end
   end
 
   describe '#process_dsl_files' do
     before do
-      Omnibus.stub(:project_root).and_return(complicated_path)
-      stub_ohai(platform: 'linux')
+      Omnibus::Config.project_root(complicated_path)
+      stub_ohai(platform: 'ubuntu', version: '12.04')
     end
 
-    after { Omnibus.reset! }
-
     it 'populates the 5 projects' do
       Omnibus.process_dsl_files
 

data/spec/unit/package_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+module Omnibus
+  describe Package::Metadata do
+    let(:instance) do
+      double(Package::Metadata,
+        path: '/path/to/package.deb.metadata.json',
+      )
+    end
+
+    let(:package) do
+      double(Package,
+        name:   'package',
+        path:   '/path/to/package.deb',
+        md5:    'abc123',
+        sha1:   'abc123',
+        sha256: 'abcd1234',
+        sha512: 'abcdef123456',
+      )
+    end
+
+    let(:data) { { foo: 'bar' } }
+
+    subject { described_class.new(package, data) }
+
+    describe '.generate' do
+      it 'writes out the file' do
+        described_class.stub(:new).and_return(instance)
+        expect(instance).to receive(:save).once
+
+        described_class.generate(package, data)
+      end
+    end
+
+    describe '.for_package' do
+      it 'raises an exception when the file does not exist' do
+        File.stub(:read).and_raise(Errno::ENOENT)
+        expect { described_class.for_package(package) }
+          .to raise_error(NoPackageMetadataFile)
+      end
+
+      it 'returns a metadata object' do
+        File.stub(:read).and_return('{ "platform": "ubuntu" }')
+        expect(described_class.for_package(package)).to be_a(described_class)
+      end
+
+      it 'loads the metadata from disk' do
+        File.stub(:read).and_return('{ "platform": "ubuntu" }')
+        instance = described_class.for_package(package)
+
+        expect(instance[:platform]).to eq('ubuntu')
+      end
+    end
+
+    describe '.path_for' do
+      it 'returns the postfixed .metadata.json' do
+        expect(described_class.path_for(package))
+          .to eq('/path/to/package.deb.metadata.json')
+      end
+    end
+
+    describe '#name' do
+      it 'returns the basename of the package' do
+        expect(subject.name).to eq('package.deb.metadata.json')
+      end
+    end
+
+    describe '#path' do
+      it 'delegates to .path_for' do
+        expect(described_class).to receive(:path_for).once
+        subject.path
+      end
+    end
+
+    describe '#save' do
+      let(:file) { double(File) }
+
+      before { File.stub(:open).and_yield(file) }
+
+      it 'saves the file to disk' do
+        expect(file).to receive(:write).once
+        subject.save
+      end
+    end
+
+    describe '#to_json' do
+      it 'generates pretty JSON' do
+        expect(subject.to_json).to eq <<-EOH.gsub(/^ {10}/, '').strip
+          {
+            "foo": "bar"
+          }
+        EOH
+      end
+    end
+  end
+
+  describe Package do
+    let(:path) { '/path/to/files/thing.deb' }
+
+    subject { described_class.new(path) }
+
+    describe '.initialize' do
+      it 'sets the path' do
+        expect(subject.instance_variables).to include(:@path)
+      end
+    end
+
+    describe '#name' do
+      it 'returns the basename of the file' do
+        expect(subject.name).to eq('thing.deb')
+      end
+    end
+
+    describe '#md5' do
+      let(:md5) { 'abcdef123456' }
+
+      before { subject.stub(:digest).with(path, :md5).and_return(md5) }
+
+      it 'returns the md5 of the package at the path' do
+        expect(subject.md5).to eq(md5)
+      end
+    end
+
+    describe '#sha256' do
+      let(:sha256) { 'abcdef123456' }
+
+      before { subject.stub(:digest).with(path, :sha256).and_return(sha256) }
+
+      it 'returns the sha256 of the package at the path' do
+        expect(subject.sha256).to eq(sha256)
+      end
+    end
+
+    describe '#sha512' do
+      let(:sha512) { 'abcdef123456' }
+
+      before { subject.stub(:digest).with(path, :sha512).and_return(sha512) }
+
+      it 'returns the sha512 of the package at the path' do
+        expect(subject.sha512).to eq(sha512)
+      end
+    end
+
+    describe '#content' do
+      context 'when the file exists' do
+        let(:content) { 'BINARY' }
+
+        before { IO.stub(:read).with(path).and_return(content) }
+
+        it 'reads the file' do
+          expect(subject.content).to eq(content)
+        end
+      end
+
+      context 'when the file does not exist' do
+        before { IO.stub(:read).and_raise(Errno::ENOENT) }
+
+        it 'raises an exception' do
+          expect { subject.content }.to raise_error(NoPackageFile)
+        end
+      end
+    end
+
+    describe '#metadata' do
+      let(:content) { '{ "platform": "ubuntu" }' }
+
+      before { IO.stub(:read).and_return(content) }
+
+      it 'returns a Metadata object' do
+        expect(subject.metadata).to be_a(Package::Metadata)
+      end
+
+      it 'reads the information in the file' do
+        expect(subject.metadata[:platform]).to eq('ubuntu')
+      end
+    end
+  end
+end

data/spec/unit/packagers/base_spec.rb

@@ -2,19 +2,21 @@ require 'stringio'
 
 module Omnibus
   describe Packager::Base do
+    before do
+      Config.package_tmp('pkg-tmp')
+    end
+
     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',
-             resources_path: nil,
-             friendly_name: 'HAMLET',
+      double(Project,
+        name: 'hamlet',
+        build_version: '1.0.0',
+        iteration: '12902349',
+        mac_pkg_identifier: 'com.chef.hamlet',
+        install_dir: '/opt/hamlet',
+        package_scripts_path: 'package-scripts',
+        files_path: 'files',
+        resources_path: nil,
+        friendly_name: 'HAMLET',
       )
     end
 
@@ -24,38 +26,6 @@ module Omnibus
       expect(subject).to be_a(Util)
     end
 
-    it 'delegates #name to @project' do
-      expect(subject.name).to eq(project.name)
-    end
-
-    it 'delegates #friendly_name to @project' do
-      expect(subject.friendly_name).to eq(project.friendly_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 {}
@@ -168,7 +138,7 @@ module Omnibus
 
         before do
           input = StringIO.new
-          input.write('<%= friendly_name %>')
+          input.write('<%= project.friendly_name %>')
           input.rewind
 
           File.stub(:open).with(source_path).and_yield(input)
@@ -245,14 +215,14 @@ module Omnibus
 
     describe '#staging_dir' do
       it 'is the project package tmp and underscored named' do
-        name = "#{project.package_tmp}/base"
+        name = "#{Config.package_tmp}/base"
         expect(subject.send(:staging_dir)).to eq(File.expand_path(name))
       end
     end
 
     describe '#staging_resources_path' do
       it 'is base/Resources under package temp' do
-        name = "#{project.package_tmp}/base/Resources"
+        name = "#{Config.package_tmp}/base/Resources"
         expect(subject.send(:staging_resources_path)).to eq(File.expand_path(name))
       end
     end

data/spec/unit/packagers/mac_pkg_spec.rb

@@ -1,24 +1,25 @@
 require 'stringio'
 require 'spec_helper'
 
-describe Omnibus::Packager::MacPkg do
-
-  let(:project_name) { 'myproject' }
-
-  let(:mac_pkg_identifier) { 'com.mycorp.myproject' }
+module Omnibus
+  describe Packager::MacPkg do
+    before do
+      Config.package_dir('/home/someuser/omnibus-myproject/pkg')
+      Config.package_tmp('/var/cache/omnibus/pkg-tmp')
+    end
 
-  let(:omnibus_root) { '/omnibus/project/root' }
+    let(:project_name) { 'myproject' }
 
-  let(:scripts_path) { "#{omnibus_root}/scripts" }
+    let(:mac_pkg_identifier) { 'com.mycorp.myproject' }
 
-  let(:package_dir) { '/home/someuser/omnibus-myproject/pkg' }
+    let(:omnibus_root) { '/omnibus/project/root' }
 
-  let(:package_tmp) { '/var/cache/omnibus/pkg-tmp' }
+    let(:scripts_path) { "#{omnibus_root}/scripts" }
 
-  let(:files_path) { "#{omnibus_root}/files" }
+    let(:files_path) { "#{omnibus_root}/files" }
 
-  let(:expected_distribution_content) do
-    <<-EOH
+    let(:expected_distribution_content) do
+      <<-EOH
 <?xml version="1.0" standalone="no"?>
 <installer-gui-script minSpecVersion="1">
     <title>Myproject</title>
@@ -40,134 +41,111 @@ describe Omnibus::Packager::MacPkg do
     </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(:pkg_signing_config) do
-    {
-      sign_pkg: false,
-      signing_identity: nil,
-    }
-  end
-
-  let(:project) do
-    double Omnibus::Project,
-           name: project_name,
-           build_version: '23.4.2',
-           iteration: 4,
-           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,
-           config: pkg_signing_config,
-           friendly_name: 'Myproject'
-  end
-
-  let(:packager) do
-    Omnibus::Packager::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 'names the component package PROJECT_NAME-core.pkg' do
-    expect(packager.component_pkg).to eq('myproject-core.pkg')
-  end
-
-  it 'names the product package PROJECT_NAME.pkg' do
-    expect(packager.package_name).to eq('myproject-23.4.2-4.pkg')
-  end
-
-  it "use's the project's package_scripts_path" do
-    expect(packager.scripts).to eq(project.package_scripts_path)
-  end
+  EOH
+    end
 
-  it 'runs pkgbuild' do
-    expect(packager).to receive(:execute).with <<-EOH.gsub(/^ {6}/, '')
-      pkgbuild \\
-        --identifier "com.mycorp.myproject" \\
-        --version "23.4.2" \\
-        --scripts "/omnibus/project/root/scripts" \\
-        --root "/opt/myproject" \\
-        --install-location "/opt/myproject" \\
-        "myproject-core.pkg"
-    EOH
-    packager.build_component_pkg
-  end
+    let(:expected_distribution_path) { '/var/cache/omnibus/pkg-tmp/mac_pkg/Distribution' }
+
+    let(:project) do
+      double(Project,
+        name: project_name,
+        build_version: '23.4.2',
+        iteration: 4,
+        maintainer: "Joe's Software",
+        install_dir: '/opt/myproject',
+        files_path: files_path,
+        package_scripts_path: scripts_path,
+        mac_pkg_identifier: mac_pkg_identifier,
+        friendly_name: 'Myproject'
+      )
+    end
 
-  it 'generates a Distribution file describing the product package content' do
-    file = StringIO.new
-    File.stub(:open).with(any_args).and_yield(file)
+    let(:packager) { Packager::MacPkg.new(project) }
 
-    expect(file).to receive(:puts).with(expected_distribution_content)
-    packager.generate_distribution
-  end
+    it 'names the component package PROJECT_NAME-core.pkg' do
+      expect(packager.component_pkg).to eq('myproject-core.pkg')
+    end
 
-  describe 'generating the distribution file' do
-    let(:distribution_file) { StringIO.new }
+    it 'names the product package PROJECT_NAME.pkg' do
+      expect(packager.package_name).to eq('myproject-23.4.2-4.pkg')
+    end
 
-    before do
-      expect(File).to receive(:open)
-        .with(expected_distribution_path, 'w', 0600)
-        .and_yield(distribution_file)
+    it 'runs pkgbuild' do
+      expect(packager).to receive(:execute).with <<-EOH.gsub(/^ {8}/, '')
+        pkgbuild \\
+          --identifier "com.mycorp.myproject" \\
+          --version "23.4.2" \\
+          --scripts "/omnibus/project/root/scripts" \\
+          --root "/opt/myproject" \\
+          --install-location "/opt/myproject" \\
+          "myproject-core.pkg"
+      EOH
+      packager.build_component_pkg
     end
 
-    it 'writes the distribution file to the staging directory' do
+    it 'generates a Distribution file describing the product package content' do
+      file = StringIO.new
+      File.stub(:open).with(any_args).and_yield(file)
+
+      expect(file).to receive(:puts).with(expected_distribution_content)
       packager.generate_distribution
-      expect(distribution_file.string).to eq(expected_distribution_content)
     end
-  end
 
-  describe 'building the product package' do
-    it 'generates the distribution and runs productbuild' do
-      expect(packager).to receive(:execute).with ['productbuild',
-                                                  %Q(--distribution "/var/cache/omnibus/pkg-tmp/mac_pkg/Distribution"),
-                                                  %Q(--resources "/var/cache/omnibus/pkg-tmp/mac_pkg/Resources"),
-                                                  '/home/someuser/omnibus-myproject/pkg/myproject-23.4.2-4.pkg',
-      ].join(' ')
-      packager.build_product_pkg
-    end
-  end
+    describe 'generating the distribution file' do
+      let(:distribution_file) { StringIO.new }
 
-  context 'when pkg signing is enabled' do
-    let(:pkg_signing_config) do
-      {
-        sign_pkg: true,
-        signing_identity: 'My Special Identity',
-      }
-    end
+      before do
+        expect(File).to receive(:open)
+          .with(expected_distribution_path, 'w', 0600)
+          .and_yield(distribution_file)
+      end
 
-    it 'includes the signing parameters in the product build command' do
-      expect(packager).to receive(:execute).with ['productbuild',
-                                                  %Q(--distribution "/var/cache/omnibus/pkg-tmp/mac_pkg/Distribution"),
-                                                  %Q(--resources "/var/cache/omnibus/pkg-tmp/mac_pkg/Resources"),
-                                                  %Q(--sign "My Special Identity"),
-                                                  '/home/someuser/omnibus-myproject/pkg/myproject-23.4.2-4.pkg',
-      ].join(' ')
-      packager.build_product_pkg
+      it 'writes the distribution file to the staging directory' do
+        packager.generate_distribution
+        expect(distribution_file.string).to eq(expected_distribution_content)
+      end
     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 'uses com.example.PROJECT_NAME as the identifier' do
-      expect(packager.identifier).to eq('test.joessoftware.pkg.myproject')
+    describe '#build_product_pkg' do
+      context 'when pkg signing is disabled' do
+        it 'generates the distribution and runs productbuild' do
+          expect(packager).to receive(:execute).with <<-EOH.gsub(/^ {12}/, '')
+            productbuild \\
+              --distribution "/var/cache/omnibus/pkg-tmp/mac_pkg/Distribution" \\
+              --resources "/var/cache/omnibus/pkg-tmp/mac_pkg/Resources" \\
+              "/home/someuser/omnibus-myproject/pkg/myproject-23.4.2-4.pkg"
+          EOH
+
+          packager.build_product_pkg
+        end
+      end
+
+      context 'when pkg signing is enabled' do
+        before do
+          Config.sign_pkg(true)
+          Config.signing_identity('My Special Identity')
+        end
+
+        it 'includes the signing parameters in the product build command' do
+          expect(packager).to receive(:execute).with  <<-EOH.gsub(/^ {12}/, '')
+            productbuild \\
+              --distribution "/var/cache/omnibus/pkg-tmp/mac_pkg/Distribution" \\
+              --resources "/var/cache/omnibus/pkg-tmp/mac_pkg/Resources" \\
+              --sign "My Special Identity" \\
+              "/home/someuser/omnibus-myproject/pkg/myproject-23.4.2-4.pkg"
+            EOH
+          packager.build_product_pkg
+        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 'uses com.example.PROJECT_NAME as the identifier' do
+          expect(packager.identifier).to eq('test.joessoftware.pkg.myproject')
+        end
+      end
     end
   end
 end