omnibus 3.2.2 → 4.0.0.beta.1

data/spec/unit/packagers/base_spec.rb

@@ -2,252 +2,138 @@ 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_dir: '/opt/hamlet',
-        package_scripts_path: 'package-scripts',
-        files_path: 'files',
-        resources_path: nil,
-        friendly_name: 'HAMLET',
-      )
-    end
-
-    subject { described_class.new(project) }
-
-    it 'includes Util' do
-      expect(subject).to be_a(Util)
-    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)
+      Project.new.tap do |project|
+        project.name('project')
+        project.install_dir('/opt/project')
+        project.homepage('https://example.com')
+        project.build_version('1.2.3')
+        project.build_iteration('2')
+        project.maintainer('Chef Software')
       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
+    before do
+      # Force the Dir.mktmpdir call on staging_dir
+      allow(Dir).to receive(:mktmpdir).and_return('/tmp/dir')
 
-      it 'is a required phase' do
-        described_class.instance_variable_set(:@build, nil)
-        expect { described_class.build }.to raise_error(AbstractMethod)
-      end
+      Config.package_dir(tmp_path)
     end
 
-    describe '.clean' do
-      it 'sets the value of the block' do
-        block = proc {}
-        described_class.clean(&block)
+    subject { described_class.new(project) }
 
-        expect(described_class.clean).to eq(block)
-      end
+    it 'includes Cleanroom' do
+      expect(subject).to be_a(Cleanroom)
     end
 
-    describe '#create_directory' do
-      before { allow(FileUtils).to receive(: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
+    it 'includes Digestable' do
+      expect(subject).to be_a(Digestable)
     end
 
-    describe '#remove_directory' do
-      before { allow(FileUtils).to receive(:rm_rf) }
-
-      it 'remove the directory' do
-        expect(FileUtils).to receive(:rm_rf).with('/foo/bar')
-        subject.remove_directory('/foo/bar')
-      end
+    it 'includes Logging' do
+      expect(subject).to be_a(Logging)
     end
 
-    describe '#purge_directory' do
-      before do
-        allow(subject).to receive(:remove_directory)
-        allow(subject).to receive(: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
+    it 'includes NullArgumentable' do
+      expect(subject).to be_a(NullArgumentable)
     end
 
-    describe '#copy_file' do
-      before { allow(FileUtils).to receive(: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
+    it 'includes Templating' do
+      expect(subject).to be_a(Templating)
     end
 
-    describe '#copy_directory' do
-      before do
-        allow(FileUtils).to receive(:cp_r)
-        allow(Dir).to receive(:[]).and_return(['baz/file'])
-      end
-
-      it 'copies the directory' do
-        expect(FileUtils).to receive(:cp_r).with(['baz/file'], 'bar')
-        subject.copy_directory('baz', 'bar')
-      end
+    it 'includes Util' do
+      expect(subject).to be_a(Util)
     end
 
-    describe '#render_template' do
-      it 'return when source is not an erb template' do
-        expect(File).not_to receive(:open)
-        subject.render_template('source.txt')
-      end
-
-      shared_examples_for 'render_template' do
-        let(:output) { StringIO.new }
-
-        before do
-          input = StringIO.new
-          input.write('<%= project.friendly_name %>')
-          input.rewind
-
-          allow(File).to receive(:open).with(source_path).and_yield(input)
-          allow(File).to receive(:open).with(expected_destination_path, 'w').and_yield(output)
-
-          expect(subject).to receive(:remove_file).with(source_path)
-        end
-
-        it 'should render correctly' do
-          subject.render_template(source_path, destination_path)
-          expect(output.string).to eq('HAMLET')
-        end
-      end
-
-      context 'when destination is specified' do
-        let(:source_path) { 'source.txt.erb' }
-        let(:destination_path) { 'destination.txt' }
-        let(:expected_destination_path) { destination_path }
-
-        include_examples 'render_template'
-      end
-
-      context 'when destination is not specified' do
-        let(:source_path) { 'source.txt.erb' }
-        let(:destination_path) { nil }
-        let(:expected_destination_path) { 'source.txt' }
-
-        include_examples 'render_template'
+    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 '#remove_file' do
-      before { allow(FileUtils).to receive(:rm_f) }
+    describe '.setup' do
+      it 'sets the value of the block' do
+        block = proc {}
+        described_class.setup(&block)
 
-      it 'removes the file' do
-        expect(FileUtils).to receive(:rm_f).with('/foo/bar')
-        subject.remove_file('/foo/bar')
+        expect(described_class.setup).to eq(block)
       end
     end
 
-    describe '#execute' do
-      before { allow(subject).to receive(:shellout!) }
-
-      it 'shellsout' do
-        expect(subject).to receive(:shellout!)
-          .with('echo "hello"', timeout: 3600, cwd: anything)
-        subject.execute('echo "hello"')
-      end
-    end
+    describe '.build' do
+      it 'sets the value of the block' do
+        block = proc {}
+        described_class.build(&block)
 
-    describe '#assert_presence!' do
-      it 'raises a MissingAsset exception when the file does not exist' do
-        allow(File).to receive(:exist?).and_return(false)
-        expect { subject.assert_presence!('foo') }.to raise_error(MissingAsset)
+        expect(described_class.build).to eq(block)
       end
     end
 
     describe '#run!' do
       before do
-        allow(described_class).to receive(:validate).and_return(proc {})
+        allow(subject).to receive(:remove_directory)
+        allow(Metadata).to receive(:generate)
+
         allow(described_class).to receive(:setup).and_return(proc {})
         allow(described_class).to receive(:build).and_return(proc {})
-        allow(described_class).to receive(:clean).and_return(proc {})
+
+        allow(subject).to receive(:package_name).and_return('foo')
       end
 
       it 'calls the methods in order' do
         expect(described_class).to receive(:setup).ordered
-        expect(described_class).to receive(:validate).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 = "#{Config.package_tmp}/base"
-        expect(subject.send(:staging_dir)).to eq(File.expand_path(name))
+      it 'creates a temporary directory' do
+        expect(Dir).to receive(:mktmpdir)
+        subject.send(:staging_dir)
       end
     end
 
-    describe '#staging_resources_path' do
-      it 'is base/Resources under package temp' do
-        name = "#{Config.package_tmp}/base/Resources"
-        expect(subject.send(:staging_resources_path)).to eq(File.expand_path(name))
+    describe '#resource_path' do
+      let(:id) { :base }
+      before { allow(subject).to receive(:id).and_return(id) }
+
+      context 'when a local resource exists' do
+        let(:resources_path) { '/resources/path' }
+
+        before do
+          project.resources_path(resources_path)
+
+          allow(File).to receive(:exist?)
+            .with(/#{resources_path}/)
+            .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")
+        end
       end
-    end
 
-    describe '#resource' do
-      it 'prefixes to the resources_path' do
-        path = 'pkg-tmp/base/Resources/icon.png'
-        expect(subject.send(:resource, 'icon.png')).to eq(File.expand_path(path))
+      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
 
     describe '#resoures_path' do
-      context 'when project does not define resources_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
+      let(:id) { :base }
+      let(:resources_path) { '/resources/path' }
+
+      before do
+        project.resources_path(resources_path)
+        allow(subject).to receive(:id).and_return(id)
       end
 
-      context 'when project defines resources_path' do
-        before { allow(project).to receive(:resources_path).and_return('project/specific') }
-        it 'is the project resources_path, underscored_name, and Resources' do
-          path = 'project/specific/base/Resources'
-          expect(subject.send(:resources_path)).to eq(File.expand_path(path))
-        end
+      it 'returns the path with the id' do
+        expect(subject.resources_path).to eq("#{resources_path}/#{id}")
       end
     end
   end

data/spec/unit/packagers/bff_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+module Omnibus
+  describe Packager::BFF do
+    let(:project) do
+      Project.new.tap do |project|
+        project.name('project')
+        project.homepage('https://example.com')
+        project.install_dir('/opt/project')
+        project.build_version('1.2.3')
+        project.build_iteration('2')
+        project.maintainer('Chef Software')
+      end
+    end
+
+    subject { described_class.new(project) }
+
+    let(:project_root) { "#{tmp_path}/project/root" }
+    let(:package_dir)  { "#{tmp_path}/package/dir" }
+    let(:staging_dir)  { "#{tmp_path}/staging/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(staging_dir)
+    end
+
+    describe '#id' do
+      it 'is :bff' do
+        expect(subject.id).to eq(:bff)
+      end
+    end
+
+    describe '#package_name' do
+      before do
+        allow(subject).to receive(:safe_architecture).and_return('x86_64')
+      end
+
+      it 'includes the name, version, and build iteration' do
+        expect(subject.package_name).to eq('project.1.2.3.2.x86_64.bff')
+      end
+    end
+
+    describe '#write_gen_template' do
+      before do
+        allow(subject).to receive(:safe_architecture).and_return('x86_64')
+      end
+
+      let(:gen_file) { "#{staging_dir}/gen.template" }
+
+      it 'generates the file' do
+        subject.write_gen_template
+        expect(gen_file).to be_a_file
+      end
+
+      it 'has the correct content' do
+        subject.write_gen_template
+        contents = File.read(gen_file)
+
+        expect(contents).to include("Package Name: project")
+        expect(contents).to include("Package VRMF: 1.2.3.2")
+        expect(contents).to include("Update: N")
+        expect(contents).to include("Fileset")
+        expect(contents).to include("  Fileset Name: project")
+        expect(contents).to include("  Fileset VRMF: 1.2.3.2")
+        expect(contents).to include("  Fileset Description: The full stack of project")
+        expect(contents).to include("  USRLIBLPPFiles")
+        expect(contents).to include("    Configuration Script:")
+        expect(contents).to include("    Unconfiguration Script:")
+        expect(contents).to include("  EOUSRLIBLPPFiles")
+        expect(contents).to include("  Bosboot required: N")
+        expect(contents).to include("  License agreement acceptance required: N")
+        expect(contents).to include("  Include license files in this package: N")
+        expect(contents).to include("  Requisites:")
+        expect(contents).to include("  ROOT Part: Y")
+        expect(contents).to include("  ROOTFiles")
+        expect(contents).to include("  EOROOTFiles")
+        expect(contents).to include("EOFileset")
+      end
+
+      context 'when files and directories are present' do
+        before do
+          create_file("#{staging_dir}/.file1")
+          create_file("#{staging_dir}/file2")
+          create_directory("#{staging_dir}/.dir1")
+          create_directory("#{staging_dir}/dir2")
+        end
+
+        it 'writes them into the template' do
+          subject.write_gen_template
+          contents = File.read(gen_file)
+
+          expect(contents).to include("/.dir1")
+          expect(contents).to include("/.file1")
+          expect(contents).to include("/dir2")
+          expect(contents).to include("/file2")
+        end
+      end
+    end
+
+    describe '#create_bff_file' do
+      before do
+        allow(subject).to receive(:shellout!)
+        allow(Dir).to receive(:chdir) { |_, &b| b.call }
+      end
+
+      it 'logs a message' do
+        output = capture_logging { subject.create_bff_file }
+        expect(output).to include('Creating .bff file')
+      end
+
+      it 'uses the correct command' do
+        expect(subject).to receive(:shellout!)
+          .with(/\/usr\/sbin\/mkinstallp -d/)
+        subject.create_bff_file
+      end
+    end
+
+    describe '#safe_project_name' do
+      context 'when the project name is "safe"' do
+        it 'returns the value without logging a message' do
+          expect(subject.safe_project_name).to eq('project')
+          expect(subject).to_not receive(:log)
+        end
+      end
+
+      context 'when the project name has invalid characters' do
+        before { project.name("Pro$ject123.for-realz_2") }
+
+        it 'returns the value while logging a message' do
+          output = capture_logging do
+            expect(subject.safe_project_name).to eq('pro-ject123.for-realz-2')
+          end
+
+          expect(output).to include("The `name' compontent of BFF package names can only include")
+        end
+      end
+    end
+
+    describe '#bff_version' do
+      it 'returns the build version up with the build iteration' do
+        expect(subject.bff_version).to eq('1.2.3.2')
+      end
+    end
+
+    describe '#safe_architecture' do
+      before do
+        stub_ohai(platform: 'ubuntu', version: '12.04') do |data|
+          data['kernel']['machine'] = 'i386'
+        end
+      end
+
+      it 'returns the value from Ohai' do
+        expect(subject.safe_architecture).to eq('i386')
+      end
+    end
+  end
+end