omnibus 5.4.0 → 5.5.0

data/spec/unit/omnibus_spec.rb

@@ -1,32 +1,32 @@
-require 'omnibus'
-require 'spec_helper'
+require "omnibus"
+require "spec_helper"
 
 describe Omnibus do
   before do
     allow(File).to receive(:directory?).and_return(true)
 
     allow(Gem::Specification).to receive(:find_all_by_name)
-      .with('omnibus-software')
-      .and_return([double(gem_dir: File.join(tmp_path, '/gem/omnibus-software'))])
+      .with("omnibus-software")
+      .and_return([double(gem_dir: File.join(tmp_path, "/gem/omnibus-software"))])
 
     allow(Gem::Specification).to receive(:find_all_by_name)
-      .with('custom-omnibus-software')
-      .and_return([double(gem_dir: File.join(tmp_path, '/gem/custom-omnibus-software'))])
+      .with("custom-omnibus-software")
+      .and_return([double(gem_dir: File.join(tmp_path, "/gem/custom-omnibus-software"))])
 
-    Omnibus::Config.project_root(File.join(tmp_path, '/foo/bar'))
-    Omnibus::Config.local_software_dirs([File.join(tmp_path, '/local'), File.join(tmp_path, '/other')])
-    Omnibus::Config.software_gems(['omnibus-software', 'custom-omnibus-software'])
+    Omnibus::Config.project_root(File.join(tmp_path, "/foo/bar"))
+    Omnibus::Config.local_software_dirs([File.join(tmp_path, "/local"), File.join(tmp_path, "/other")])
+    Omnibus::Config.software_gems(["omnibus-software", "custom-omnibus-software"])
   end
 
   describe '#which' do
-    it 'returns nil when the file does not exist' do
-      stub_env('PATH', nil)
-      expect(subject.which('not_a_real_executable')).to be nil
+    it "returns nil when the file does not exist" do
+      stub_env("PATH", nil)
+      expect(subject.which("not_a_real_executable")).to be nil
     end
 
-    it 'returns the path when the file exists' do
+    it "returns the path when the file exists" do
 
-      ruby_cmd = windows? ? 'ruby.exe' : 'ruby'
+      ruby_cmd = windows? ? "ruby.exe" : "ruby"
       ruby = Bundler.which(ruby_cmd)
       expect(subject.which(ruby)).to eq(ruby)
       expect(subject.which(ruby_cmd)).to eq(ruby)
@@ -36,50 +36,50 @@ describe Omnibus do
   describe '#project_path' do
     before do
       allow(Omnibus).to receive(:project_map)
-        .and_return('chef' => '/projects/chef')
+        .and_return("chef" => "/projects/chef")
     end
 
-    it 'accepts a string' do
-      expect(subject.project_path('chef')).to eq('/projects/chef')
+    it "accepts a string" do
+      expect(subject.project_path("chef")).to eq("/projects/chef")
     end
 
-    it 'accepts a symbol' do
-      expect(subject.project_path(:chef)).to eq('/projects/chef')
+    it "accepts a symbol" do
+      expect(subject.project_path(:chef)).to eq("/projects/chef")
     end
 
-    it 'returns nil when the project does not exist' do
-      expect(subject.project_path('bacon')).to be nil
+    it "returns nil when the project does not exist" do
+      expect(subject.project_path("bacon")).to be nil
     end
   end
 
   describe '#software_path' do
     before do
       allow(Omnibus).to receive(:software_map)
-        .and_return('chef' => '/software/chef')
+        .and_return("chef" => "/software/chef")
     end
 
-    it 'accepts a string' do
-      expect(subject.software_path('chef')).to eq('/software/chef')
+    it "accepts a string" do
+      expect(subject.software_path("chef")).to eq("/software/chef")
     end
 
-    it 'accepts a symbol' do
-      expect(subject.software_path(:chef)).to eq('/software/chef')
+    it "accepts a symbol" do
+      expect(subject.software_path(:chef)).to eq("/software/chef")
     end
 
-    it 'returns nil when the project does not exist' do
-      expect(subject.software_path('bacon')).to be nil
+    it "returns nil when the project does not exist" do
+      expect(subject.software_path("bacon")).to be nil
     end
   end
 
   describe '#possible_paths_for' do
-    it 'searches all paths' do
-      expect(subject.possible_paths_for('file')).to eq(%w(
+    it "searches all paths" do
+      expect(subject.possible_paths_for("file")).to eq(%w{
         /foo/bar/file
         /local/file
         /other/file
         /gem/omnibus-software/file
         /gem/custom-omnibus-software/file
-      ).map { |path| File.join(tmp_path, path) })
+      }.map { |path| File.join(tmp_path, path) })
     end
   end
 end

data/spec/unit/package_spec.rb

@@ -1,68 +1,68 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Omnibus
   describe Package do
-    let(:path) { windows? ? 'C:/path/to/files/thing.deb' : '/path/to/files/thing.deb' }
+    let(:path) { windows? ? "C:/path/to/files/thing.deb" : "/path/to/files/thing.deb" }
 
     subject { described_class.new(path) }
 
-    describe '.initialize' do
-      it 'sets the path' do
+    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')
+      it "returns the basename of the file" do
+        expect(subject.name).to eq("thing.deb")
       end
     end
 
     describe '#md5' do
-      let(:md5) { 'abcdef123456' }
+      let(:md5) { "abcdef123456" }
 
       before { allow(subject).to receive(:digest).with(path, :md5).and_return(md5) }
 
-      it 'returns the md5 of the package at the path' do
+      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' }
+      let(:sha256) { "abcdef123456" }
 
       before { allow(subject).to receive(:digest).with(path, :sha256).and_return(sha256) }
 
-      it 'returns the sha256 of the package at the path' do
+      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' }
+      let(:sha512) { "abcdef123456" }
 
       before { allow(subject).to receive(:digest).with(path, :sha512).and_return(sha512) }
 
-      it 'returns the sha512 of the package at the path' do
+      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' }
+      context "when the file exists" do
+        let(:content) { "BINARY" }
 
         before { allow(IO).to receive(:read).with(path).and_return(content) }
 
-        it 'reads the file' do
+        it "reads the file" do
           expect(subject.content).to eq(content)
         end
       end
 
-      context 'when the file does not exist' do
+      context "when the file does not exist" do
         before { allow(IO).to receive(:read).and_raise(Errno::ENOENT) }
 
-        it 'raises an exception' do
+        it "raises an exception" do
           expect { subject.content }.to raise_error(NoPackageFile)
         end
       end
@@ -73,12 +73,12 @@ module Omnibus
 
       before { allow(IO).to receive(:read).and_return(content) }
 
-      it 'returns a Metadata object' do
+      it "returns a Metadata object" do
         expect(subject.metadata).to be_a(Metadata)
       end
 
-      it 'reads the information in the file' do
-        expect(subject.metadata[:platform]).to eq('ubuntu')
+      it "reads the information in the file" do
+        expect(subject.metadata[:platform]).to eq("ubuntu")
       end
     end
   end

data/spec/unit/packager_spec.rb

@@ -1,63 +1,69 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Omnibus
   describe Packager do
-    describe '.for_current_system' do
-      context 'on Mac OS X' do
-        before { stub_ohai(platform: 'mac_os_x', version: '10.9.2') }
-        it 'prefers PKG' do
-            expect(described_class.for_current_system).to eq(Packager::PKG)
-          end
+    describe ".for_current_system" do
+      context "on Mac OS X" do
+        before { stub_ohai(platform: "mac_os_x", version: "10.9.2") }
+        it "prefers PKG" do
+          expect(described_class.for_current_system).to eq([Packager::PKG])
+        end
       end
 
-      context 'on Windows' do
-        before { stub_ohai(platform: 'windows', version: '2012') }
-          it 'prefers MSI' do
-            expect(described_class.for_current_system).to eq(Packager::MSI)
-          end
+      context "on Windows 2012" do
+        before { stub_ohai(platform: "windows", version: "2012") }
+        it "prefers MSI and APPX" do
+          expect(described_class.for_current_system).to eq([Packager::MSI, Packager::APPX])
+        end
       end
 
-      context 'on Solaris 11' do
-        before { stub_ohai(platform: 'solaris2', version: '5.11') }
-          it 'prefers IPS' do
-            expect(described_class.for_current_system).to eq(Packager::IPS)
-          end
+      context "on Windows 2008 R2" do
+        before { stub_ohai(platform: "windows", version: "2008R2") }
+        it "prefers MSI only" do
+          expect(described_class.for_current_system).to eq([Packager::MSI])
+        end
       end
 
-      context 'on Solaris 10' do
-        before { stub_ohai(platform: 'solaris2', version: '5.10') }
-          it 'prefers Solaris' do
-            expect(described_class.for_current_system).to eq(Packager::Solaris)
-          end
+      context "on Solaris 11" do
+        before { stub_ohai(platform: "solaris2", version: "5.11") }
+        it "prefers IPS" do
+          expect(described_class.for_current_system).to eq([Packager::IPS])
+        end
       end
 
+      context "on Solaris 10" do
+        before { stub_ohai(platform: "solaris2", version: "5.10") }
+        it "prefers Solaris" do
+          expect(described_class.for_current_system).to eq([Packager::Solaris])
+        end
+      end
 
-      context 'on aix' do
-        before { stub_ohai(platform: 'aix', version: '7.1') }
-          it 'prefers BFF' do
-            expect(described_class.for_current_system).to eq(Packager::BFF)
-          end
+      context "on aix" do
+        before { stub_ohai(platform: "aix", version: "7.1") }
+        it "prefers BFF" do
+          expect(described_class.for_current_system).to eq([Packager::BFF])
+        end
       end
 
-      context 'on fedora' do
-        before { stub_ohai(platform: 'fedora', version: '20') }
-          it 'prefers RPM' do
-            expect(described_class.for_current_system).to eq(Packager::RPM)
-          end
+      context "on fedora" do
+        before { stub_ohai(platform: "fedora", version: "20") }
+        it "prefers RPM" do
+          expect(described_class.for_current_system).to eq([Packager::RPM])
+        end
       end
 
-      context 'on debian' do
-        before { stub_ohai(platform: 'debian', version: '7.2') }
-          it 'prefers RPM' do
-            expect(described_class.for_current_system).to eq(Packager::DEB)
-          end
+      context "on debian" do
+        before { stub_ohai(platform: "debian", version: "7.2") }
+        it "prefers RPM" do
+          expect(described_class.for_current_system).to eq([Packager::DEB])
+        end
       end
 
-      context 'on suse' do
-        before { stub_ohai(platform: 'suse', version: '12.0') }
-          it 'prefers RPM' do
-            expect(described_class.for_current_system).to eq(Packager::RPM)
-          end
+      context "on suse" do
+        before { stub_ohai(platform: "suse", version: "12.0") }
+        it "prefers RPM" do
+          expect(described_class.for_current_system).to eq([Packager::RPM])
+        end
       end
     end
   end

data/spec/unit/packagers/appx_spec.rb

@@ -0,0 +1,165 @@
+require "spec_helper"
+
+module Omnibus
+  describe Packager::APPX do
+    let(:project) do
+      Project.new.tap do |project|
+        project.name("project")
+        project.homepage("https://example.com")
+        project.install_dir(install_dir)
+        project.build_version("1.2.3")
+        project.build_iteration("2")
+        project.maintainer("Chef Software <maintainers@chef.io>")
+      end
+    end
+
+    subject { described_class.new(project) }
+
+    let(:project_root) { File.join(tmp_path, "project/root") }
+    let(:package_dir)  { File.join(tmp_path, "package/dir") }
+    let(:staging_dir)  { File.join(tmp_path, "staging/dir") }
+    let(:install_dir)  { File.join(tmp_path, "install/dir") }
+
+    before do
+      Config.project_root(project_root)
+      Config.package_dir(package_dir)
+
+      allow(subject).to receive(:staging_dir).and_return(staging_dir)
+      create_directory(install_dir)
+    end
+
+    describe "DSL" do
+      it "exposes :signing_identity" do
+        expect(subject).to have_exposed_method(:signing_identity)
+      end
+    end
+
+    describe '#id' do
+      it "is :pkg" do
+        expect(subject.id).to eq(:appx)
+      end
+    end
+
+    describe '#package_name' do
+      it "includes the name, version, and build iteration" do
+        expect(subject.package_name).to eq("project-1.2.3-2.appx")
+      end
+    end
+
+    describe '#write_manifest_file' do
+      before do
+        allow(subject).to receive(:shellout!).and_return(double("output", stdout: "CN=Chef "))
+        allow(subject).to receive(:signing_identity).and_return({})
+      end
+
+      it "generates the file" do
+        subject.write_manifest_file
+        expect("#{install_dir}/AppxManifest.xml").to be_a_file
+      end
+
+      it "has the correct content" do
+        subject.write_manifest_file
+        contents = File.read("#{install_dir}/AppxManifest.xml")
+
+        expect(contents).to include('Name="project"')
+        expect(contents).to include('Version="1.2.3.2"')
+        expect(contents).to include('Publisher="CN=Chef"')
+        expect(contents).to include("<DisplayName>Project</DisplayName>")
+        expect(contents).to include(
+          '<PublisherDisplayName>"Chef Software &lt;maintainers@chef.io&gt;"</PublisherDisplayName>'
+        )
+      end
+    end
+
+    describe '#windows_package_version' do
+      context "when the project build_version semver" do
+        it "returns the right value" do
+          expect(subject.windows_package_version).to eq("1.2.3.2")
+        end
+      end
+
+      context "when the project build_version is git" do
+        before { project.build_version("1.2.3-alpha.1+20140501194641.git.94.561b564") }
+
+        it "returns the right value" do
+          expect(subject.windows_package_version).to eq("1.2.3.2")
+        end
+      end
+    end
+
+    describe '#pack_command' do
+      it "returns a String" do
+        expect(subject.pack_command("foo")).to be_a(String)
+      end
+
+      it "packages install directory" do
+        expect(subject.pack_command("foo")).to(
+          include("/d \"#{subject.windows_safe_path(install_dir)}\"")
+        )
+      end
+
+      it "writes to the given appx file" do
+        expect(subject.pack_command("foo")).to include("/p foo")
+      end
+    end
+
+    context "when signing parameters are provided" do
+      let(:appx) { "someappx.appx" }
+
+      context "when invalid parameters" do
+        it "should raise an InvalidValue error when the certificate name is not a String" do
+          expect { subject.signing_identity(Object.new) }.to raise_error(InvalidValue)
+        end
+
+        it "should raise an InvalidValue error when params is not a Hash" do
+          expect { subject.signing_identity("foo", Object.new) }.to raise_error(InvalidValue)
+        end
+
+        it "should raise an InvalidValue error when params contains an invalid key" do
+          expect { subject.signing_identity("foo", bar: "baz") }.to raise_error(InvalidValue)
+        end
+      end
+
+      context "when valid parameters" do
+        before do
+          allow(subject).to receive(:shellout!)
+        end
+
+        describe '#timestamp_servers' do
+          it "defaults to using ['http://timestamp.digicert.com','http://timestamp.verisign.com/scripts/timestamp.dll']" do
+            subject.signing_identity("foo")
+            expect(subject).to receive(:try_sign).with(appx, "http://timestamp.digicert.com").and_return(false)
+            expect(subject).to receive(:try_sign).with(appx, "http://timestamp.verisign.com/scripts/timestamp.dll").and_return(true)
+            subject.sign_package(appx)
+          end
+
+          it 'uses the timestamp server if provided through the #timestamp_server dsl' do
+            subject.signing_identity("foo", timestamp_servers: "http://fooserver")
+            expect(subject).to receive(:try_sign).with(appx, "http://fooserver").and_return(true)
+            subject.sign_package(appx)
+          end
+
+          it 'tries all timestamp server if provided through the #timestamp_server dsl' do
+            subject.signing_identity("foo", timestamp_servers: ["http://fooserver", "http://barserver"])
+            expect(subject).to receive(:try_sign).with(appx, "http://fooserver").and_return(false)
+            expect(subject).to receive(:try_sign).with(appx, "http://barserver").and_return(true)
+            subject.sign_package(appx)
+          end
+
+          it 'tries all timestamp server if provided through the #timestamp_servers dsl and stops at the first available' do
+            subject.signing_identity("foo", timestamp_servers: ["http://fooserver", "http://barserver"])
+            expect(subject).to receive(:try_sign).with(appx, "http://fooserver").and_return(true)
+            expect(subject).not_to receive(:try_sign).with(appx, "http://barserver")
+            subject.sign_package(appx)
+          end
+
+          it "raises an exception if there are no available timestamp servers" do
+            subject.signing_identity("foo", timestamp_servers: "http://fooserver")
+            expect(subject).to receive(:try_sign).with(appx, "http://fooserver").and_return(false)
+            expect { subject.sign_package(appx) }.to raise_error(FailedToSignWindowsPackage)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/packagers/base_spec.rb

@@ -1,60 +1,60 @@
-require 'stringio'
+require "stringio"
 
 module Omnibus
   describe Packager::Base do
     let(:project) do
       Project.new.tap do |project|
-        project.name('project')
-        project.install_dir(File.join(tmp_path, 'opt/project'))
-        project.homepage('https://example.com')
-        project.build_version('1.2.3')
-        project.build_iteration('2')
-        project.maintainer('Chef Software')
+        project.name("project")
+        project.install_dir(File.join(tmp_path, "opt/project"))
+        project.homepage("https://example.com")
+        project.build_version("1.2.3")
+        project.build_iteration("2")
+        project.maintainer("Chef Software")
       end
     end
 
     before do
       # Force the Dir.mktmpdir call on staging_dir
-      allow(Dir).to receive(:mktmpdir).and_return(File.join(tmp_path, 'tmp/dir'))
+      allow(Dir).to receive(:mktmpdir).and_return(File.join(tmp_path, "tmp/dir"))
 
       Config.package_dir(tmp_path)
     end
 
     subject { described_class.new(project) }
 
-    it 'includes Cleanroom' do
+    it "includes Cleanroom" do
       expect(subject).to be_a(Cleanroom)
     end
 
-    it 'includes Digestable' do
+    it "includes Digestable" do
       expect(subject).to be_a(Digestable)
     end
 
-    it 'includes Logging' do
+    it "includes Logging" do
       expect(subject).to be_a(Logging)
     end
 
-    it 'includes NullArgumentable' do
+    it "includes NullArgumentable" do
       expect(subject).to be_a(NullArgumentable)
     end
 
-    it 'includes Templating' do
+    it "includes Templating" do
       expect(subject).to be_a(Templating)
     end
 
-    it 'includes Util' do
+    it "includes Util" do
       expect(subject).to be_a(Util)
     end
 
-    describe '.id' do
-      it 'defines the id method on the instance' do
+    describe ".id" do
+      it "defines the id method on the instance" do
         described_class.id(:base)
         expect(subject.id).to eq(:base)
       end
     end
 
-    describe '.setup' do
-      it 'sets the value of the block' do
+    describe ".setup" do
+      it "sets the value of the block" do
         block = proc {}
         described_class.setup(&block)
 
@@ -62,8 +62,8 @@ module Omnibus
       end
     end
 
-    describe '.build' do
-      it 'sets the value of the block' do
+    describe ".build" do
+      it "sets the value of the block" do
         block = proc {}
         described_class.build(&block)
 
@@ -72,17 +72,17 @@ module Omnibus
     end
 
     describe '#install_dir' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:install_dir)
       end
 
-      it 'returns the project instances install_dir' do
+      it "returns the project instances install_dir" do
         expect(subject.install_dir).to eq(project.install_dir)
       end
     end
 
     describe '#windows_safe_path' do
-      it 'is a DSL method' do
+      it "is a DSL method" do
         expect(subject).to have_exposed_method(:windows_safe_path)
       end
     end
@@ -95,10 +95,10 @@ module Omnibus
         allow(described_class).to receive(:setup).and_return(proc {})
         allow(described_class).to receive(:build).and_return(proc {})
 
-        allow(subject).to receive(:package_name).and_return('foo')
+        allow(subject).to receive(:package_name).and_return("foo")
       end
 
-      it 'calls the methods in order' do
+      it "calls the methods in order" do
         expect(described_class).to receive(:setup).ordered
         expect(described_class).to receive(:build).ordered
         subject.run!
@@ -106,7 +106,7 @@ module Omnibus
     end
 
     describe '#staging_dir' do
-      it 'creates a temporary directory' do
+      it "creates a temporary directory" do
         expect(Dir).to receive(:mktmpdir)
         subject.send(:staging_dir)
       end
@@ -116,8 +116,8 @@ module Omnibus
       let(:id) { :base }
       before { allow(subject).to receive(:id).and_return(id) }
 
-      context 'when a local resource exists' do
-        let(:resources_path) { File.join(tmp_path, '/resources/path') }
+      context "when a local resource exists" do
+        let(:resources_path) { File.join(tmp_path, "/resources/path") }
 
         before do
           project.resources_path(resources_path)
@@ -127,18 +127,18 @@ module Omnibus
             .and_return(true)
         end
 
-        it 'returns the local path' do
-          expect(subject.resource_path('foo/bar.erb')).to eq("#{resources_path}/#{id}/foo/bar.erb")
+        it "returns the local path" do
+          expect(subject.resource_path("foo/bar.erb")).to eq("#{resources_path}/#{id}/foo/bar.erb")
         end
 
-        it 'returns the path with the id' do
+        it "returns the path with the id" do
           expect(subject.resources_path).to eq("#{resources_path}/#{id}")
         end
       end
 
-      context 'when a local resource does not exist' do
-        it 'returns the remote path' do
-          expect(subject.resource_path('foo/bar.erb')).to eq("#{Omnibus.source_root.join("resources/#{id}/foo/bar.erb")}")
+      context "when a local resource does not exist" do
+        it "returns the remote path" do
+          expect(subject.resource_path("foo/bar.erb")).to eq("#{Omnibus.source_root.join("resources/#{id}/foo/bar.erb")}")
         end
       end
     end