fpm-cookery 0.32.0 → 0.33.0

data/spec/fixtures/hiera_config/CentOS.yaml

@@ -0,0 +1 @@
+post_install: '%{scope("workdir")}/fix_ldconfig.sh'

data/spec/fixtures/hiera_config/common.yaml

@@ -0,0 +1,12 @@
+name: fake_package
+description: >
+    For testing purposes on %{scope("platform")} only - you've been warned ;)
+version: 1.0.2
+source:
+    - http://www.dummy-url.com/archive/%{hiera("name")}-%{hiera("version")}.tar.gz
+    - :with: :git
+
+environment:
+    PREFIX: '/opt'
+
+post_install: '%{scope("workdir")}/default.sh'

data/spec/fixtures/hiera_config/custom.yaml

@@ -0,0 +1,3 @@
+environment:
+    PREFIX: '/usr/local'
+    AUTOMATED_TESTING: 1

data/spec/fixtures/hiera_config/rpm.yaml

@@ -0,0 +1,12 @@
+depends:
+    - on
+    - some
+    - rhel
+    - specific
+    - packages
+
+build_depends:
+    - on
+    - having
+    - devel-prefixed
+    - libraries

data/spec/hiera_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+require 'fpm/cookery/book'
+require 'fpm/cookery/book_hook'
+require 'fpm/cookery/facts'
+require 'fpm/cookery/hiera'
+require 'fpm/cookery/recipe'
+require 'hiera/fpm_cookery_logger'
+require 'facter'
+
+describe 'Hiera' do
+  describe 'Defaults' do
+    subject { FPM::Cookery::Hiera::Defaults }
+
+    describe '.hiera_logger' do
+      it 'provides a default logger key for Hiera' do
+        expect(subject.hiera_logger).to eq 'fpm_cookery'
+      end
+    end
+
+    describe '.hiera_hierarchy' do
+      it 'provides a default lookup hierarchy for Hiera' do
+        expect(subject.hiera_hierarchy).to contain_exactly('common')
+      end
+    end
+
+    describe '.hiera_backends' do
+      it 'provides a default backend list for Hiera' do
+        expect(subject.hiera_backends).to contain_exactly(:yaml, :json)
+      end
+    end
+  end
+
+  describe 'Fpm_cookery_logger' do
+    it 'aliases Hiera::Fpm_cookery_logger to FPM::Cookery::Log::Hiera' do
+      expect(Hiera.const_get("Fpm_cookery_logger")).to be (FPM::Cookery::Log::Hiera)
+    end
+  end
+
+  describe 'Scope' do
+    let(:scope) { FPM::Cookery::Hiera::Scope.new(recipe) }
+    include_context "recipe class", __FILE__, :platform => nil, :hiera_config => nil,
+                                              :data_dir => fixture_path('hiera_config')
+
+    describe '[]' do
+      context 'given an argument corresponding to a recipe class method' do
+        it 'returns the value returned by the class method' do
+          expect(scope['workdir']).to eq(recipe.workdir)
+        end
+      end
+
+      context 'given an argument corresponding to an FPM::Cookery::Fact class method' do
+        it 'returns the value returned by the class method' do
+          expect(scope['osmajorrelease']).to eq(FPM::Cookery::Facts.osmajorrelease)
+        end
+      end
+
+      context 'given an otherwise unresolvable argument' do
+        it 'consults Facter' do
+          expect(scope['processorcount']).to eq(Facter['processorcount'].value)
+        end
+      end
+    end
+  end
+
+  describe '#lookup' do
+    include_context "recipe class", __FILE__, :platform => nil, :hiera_config => nil,
+                                              :data_dir => fixture_path('hiera_config')
+
+    context "given default options and unset `platform' fact" do
+      it "returns values from `common.yaml' only" do
+        expect(recipe.lookup('environment')).to eq('PREFIX' => '/opt')
+        expect(recipe.lookup('version')).to eq('1.0.2')
+        expect(recipe.lookup('post_install')).to eq((recipe.workdir / 'default.sh').to_s)
+      end
+    end
+
+    context 'given a platform' do
+      before(:each) { allow(config).to receive(:platform).and_return('CentOS') }
+
+      it "prefers values from `\#{platform}.yaml'" do
+        expect(recipe.lookup('post_install')).to eq((recipe.workdir / 'fix_ldconfig.sh').to_s)
+      end
+    end
+
+    context 'given a value for ENV["FPM_HIERARCHY"]' do
+      around(:each) do |example|
+        ENV['FPM_HIERARCHY'] = env
+        example.run
+        ENV.delete('FPM_HIERARCHY')
+      end
+
+      context 'that does not correspond to an existing data file' do
+        let(:env) { 'fake' }
+
+        it 'uses data from the default data file' do
+          expect(recipe.lookup('environment')).to eq('PREFIX' => '/opt')
+        end
+      end
+
+      context 'that corresponds to an existing data file' do
+        let(:env) { 'custom' }
+
+        it 'prefers data from that file' do
+          expect(recipe.lookup('environment')).to eq('PREFIX' => '/usr/local', 'AUTOMATED_TESTING' => 1)
+        end
+      end
+    end
+  end
+
+  describe "#new" do
+    context "given a string as the option to `:config'" do
+      let(:hiera) { FPM::Cookery::Hiera::Instance.new(recipe, :config => filename) }
+
+      let(:recipe) do
+        double('Recipe').as_null_object
+      end
+
+      context "that does not refer to an existing hiera.yaml file" do
+        let(:filename) { "/probably/does/not/exist/pretty/sure/anyway" }
+
+        it "raises an error when Hiera config file does not exist" do
+          expect { hiera }.to raise_error(RuntimeError)
+        end
+      end
+
+      context "that refers to an existing hiera.yaml file" do
+        let(:filename) { 'hiera.yaml' }
+
+        around(:each) do |example|
+          Dir.mktmpdir do |dir|
+            Dir.chdir(dir) do
+              File.open(filename, 'w') do |config_file|
+                config_file.print <<-CONFIG_FILE
+                  :backends:
+                    - json
+                  :json:
+                    :datadir: '/hey/i/am/a/datadir'
+                  :hierarchy:
+                    - yakko
+                    - wakko
+                    - dot
+                CONFIG_FILE
+              end
+
+              example.run
+            end
+          end
+        end
+
+        it "loads settings from that file" do
+          expect(hiera.config[:backends]).to contain_exactly('json')
+          expect(hiera.config[:json]).to eq(:datadir => '/hey/i/am/a/datadir')
+          expect(hiera.config[:hierarchy]).to contain_exactly(*%w{yakko wakko dot})
+        end
+      end
+    end
+  end
+end

data/spec/inheritable_attr_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+require 'fpm/cookery/inheritable_attr'
+require 'fpm/cookery/path'
+
+def dsl_klass(name = nil)
+  (klass = Class.new).send(:extend, FPM::Cookery::InheritableAttr)
+  klass.class_eval(&Proc.new) if block_given?
+  klass
+end
+
+shared_examples 'attribute registration' do |attr_method, registry_method|
+  context "given an attribute created with .#{attr_method}" do
+    it "registers the attribute in the .#{registry_method} list" do
+      klass = Class.new do
+        extend FPM::Cookery::InheritableAttr
+
+        instance_eval %Q{
+          #{attr_method} :dummy_attr
+        }
+      end
+
+      expect(klass).to respond_to(registry_method)
+      expect(klass.send(registry_method)).to include(:dummy_attr)
+    end
+  end
+end
+
+shared_context 'class inheritance' do
+  let(:superklass) { dsl_klass }
+  let(:subklass) { Class.new(superklass) }
+end
+
+shared_examples 'attribute inheritance' do |attr_method, default_value, attr_name = :dummy_attr|
+  # A default implementation.  Useful for +.attr_rw+, but should probably be
+  # overridden for the other DSL methods.
+  let(:attr_setter) {
+    Class.new do
+      def self.call(k, m, v)
+        k.send(m, v)
+      end
+    end
+  }
+
+  describe 'created attribute' do
+    it 'is defined on class' do
+      expect(superklass).to respond_to(attr_name)
+    end
+
+    it "is #{default_value.inspect} by default" do
+      expect(superklass.send(attr_name)).to eq(default_value)
+    end
+
+    it 'sets the attribute' do
+      attr_setter.(superklass, attr_name, value)
+      expect(superklass.send(attr_name)).to eq value
+    end
+  end
+
+  describe 'child class' do
+    describe 'inherited attribute' do
+      it 'inherits its value from the superclass' do
+        attr_setter.(superklass, attr_name, value)
+        expect(subklass.send(attr_name)).to eq value
+      end
+
+      context 'when altered' do
+        it 'does not propagate to the superclass' do
+          attr_setter.(superklass, attr_name, value)
+          attr_setter.(subklass, attr_name, child_value)
+          expect(superklass.send(attr_name)).to eq value
+        end
+      end
+    end
+  end
+end
+
+shared_context 'inheritable attributes' do |attr_method, default_value, attr_name = :dummy_attr|
+  include_context 'class inheritance'
+  include_examples 'attribute inheritance', attr_method, default_value
+
+  before(:example) do
+    missing = [:value, :child_value].reject { |m| respond_to?(m) }
+    raise "Missing required methods: #{missing.join(', ')}" unless missing.empty?
+
+    superklass.instance_eval do
+      send(attr_method, attr_name)
+    end
+  end
+end
+
+describe FPM::Cookery::InheritableAttr do
+  describe '.register_attrs' do
+    describe '.attr_rw' do
+      include_examples 'attribute registration', 'attr_rw', 'scalar_attrs'
+    end
+
+    describe '.attr_rw_list' do
+      include_examples 'attribute registration', 'attr_rw_list', 'list_attrs'
+    end
+
+    describe '.attr_rw_hash' do
+      include_examples 'attribute registration', 'attr_rw_hash', 'hash_attrs'
+    end
+
+    describe '.attr_rw_path' do
+      include_examples 'attribute registration', 'attr_rw_path', 'path_attrs'
+    end
+  end
+
+  describe '.attr_rw' do
+    include_context 'inheritable attributes', 'attr_rw', nil do
+      let(:value) { 'that' }
+      let(:child_value) { 'the other' }
+    end
+  end
+
+  describe '.attr_rw_list' do
+    include_context 'inheritable attributes', 'attr_rw_list', [] do
+      let(:attr_setter) {
+        Class.new do
+          def self.call(k, m, v)
+            k.send(m, *v)
+          end
+        end
+      }
+
+      let(:value) { %w{so la ti do} }
+      let(:child_value) { %w{fee fi fo fum} }
+    end
+  end
+
+  describe '.attr_rw_hash' do
+    include_context 'inheritable attributes', 'attr_rw_hash', {} do
+      let(:value) { {:name => 'mike', :rank => 'colonel' } }
+      let(:child_value) { {:name => 'mike', :favorite_color => 'puce' } }
+    end
+
+    describe 'created attribute' do
+      before do
+        superklass.instance_eval do
+          attr_rw_hash :metadata
+        end
+
+        superklass.metadata({ :radius => 4.172, :weight => 4 })
+      end
+
+      it 'merges its argument into the existing attribute value' do
+        superklass.metadata({ :weight => 7, :height => 12.3 })
+        expect(superklass.metadata).to eq({
+          :height => 12.3,
+          :weight => 7,
+          :radius => 4.172
+        })
+      end
+
+      it 'supports []= assignment' do
+        expect { superklass.metadata[:age] = 10000 }.not_to raise_error
+        expect(superklass.metadata).to include(:age => 10000)
+      end
+
+      context 'from child class' do
+        it 'does not propagate changes to the parent class' do
+          superklass.metadata[:tags] = %w{a b c}
+          subklass.metadata[:tags] << 'd'
+          expect(superklass.metadata[:tags]).not_to include('d')
+        end
+      end
+    end
+  end
+
+  describe '.attr_rw_path' do
+    include_context 'inheritable attributes', 'attr_rw_path', nil do
+      let(:attr_setter) {
+        Class.new do
+          def self.call(k, m, v)
+            k.send(:"#{m}=", v)
+          end
+        end
+      }
+
+      let(:value) { FPM::Cookery::Path.new('/var/spool') }
+      let(:child_value) { FPM::Cookery::Path.new('/proc/self') }
+    end
+
+    it 'returns an FPM::Cookery::Path object' do
+      superklass.attr_rw_path :home
+      superklass.home = "/where/the/heart/is"
+      expect(superklass.home).to be_an(FPM::Cookery::Path)
+    end
+  end
+
+  describe '.inherit_for' do
+    include_context 'class inheritance'
+
+    context 'given a method name that the superclass does not respond to' do
+      it 'returns nil' do
+        expect(superklass).not_to respond_to(:blech)
+        expect(FPM::Cookery::InheritableAttr.inherit_for(subklass, :blech)).to be nil
+      end
+    end
+  end
+end

data/spec/package_dir_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'fpm/cookery/package/dir'
+require 'fpm/cookery/recipe'
+
+describe FPM::Cookery::Package::Dir do
+  let(:config) { { :input => input } }
+  let(:input) { %w{foo bar baz} }
+
+  let(:recipe) do
+    Class.new(FPM::Cookery::Recipe) do
+      description 'a test package'
+      name 'boo'
+      version '8.5'
+    end
+  end
+
+  let(:package) do
+    described_class.new(recipe, config)
+  end
+
+  let(:fpm) do
+    double('FPM').as_null_object
+  end
+
+  before do
+    allow(recipe).to receive(:config).and_return(double('Config').as_null_object)
+    allow(FPM::Package::Dir).to receive(:new).and_return(fpm)
+  end
+
+  context '#package_input' do
+    it 'calls the fpm package creation with a clean environment' do
+      expect(fpm).to receive(:input).exactly(input.length).times
+
+      package # Trigger object creation and package_input call.
+    end
+  end
+end

data/spec/package_maintainer_spec.rb

@@ -58,7 +58,10 @@ describe 'Maintainer' do
 
     context 'without valid git data' do
       before do
-        allow(FPM::Cookery::Shellout).to receive(:git_config_get).and_return(nil)
+        allow(FPM::Cookery::Shellout).to receive(:git_config_get).and_raise(
+          FPM::Cookery::Shellout::CommandFailed, 'whoops!'
+        )
+
         allow(Socket).to receive(:gethostname).and_return('hostname')
       end
 

data/spec/package_version_spec.rb

@@ -140,4 +140,54 @@ describe 'Version' do
       expect(version.to_str).to eq('1.3-1.foo')
     end
   end
+
+  describe '#version' do
+    context 'given a colon-delimited string in recipe.version' do
+      context 'where version and epoch are defined' do
+        before(:each) { recipe.version = '8675309:3.1.1'}
+
+        it 'returns the version and epoch' do
+          expect(version.version).to eq('3.1.1')
+          expect(version.epoch).to eq('8675309')
+        end
+      end
+
+      context 'where only version is defined' do
+        before(:each) { recipe.version = ':2.1' }
+
+        it 'returns the version and sets epoch to nil' do
+          expect(version.version).to eq('2.1')
+          expect(version.epoch).to be nil
+        end
+      end
+
+      context 'where only epoch is defined' do
+        before(:each) { recipe.version = '12345:' }
+
+        it 'returns the epoch as version and sets epoch to nil' do
+          expect(version.version).to eq('12345')
+          expect(version.epoch).to be nil
+        end
+      end
+
+    end
+
+    context 'given a nil recipe.version' do
+      before(:each) { recipe.version = nil }
+
+      it 'returns the default version' do
+        expect(version.version).to eq(klass::DEFAULT_VERSION)
+        expect(version.epoch).to be nil
+      end
+    end
+
+    context 'given a recipe.version containing the empty string' do
+      before(:each) { recipe.version = '' }
+
+      it 'returns the default version' do
+        expect(version.version).to eq(klass::DEFAULT_VERSION)
+        expect(version.epoch).to be nil
+      end
+    end
+  end
 end