fpm-cookery 0.32.0 → 0.33.0

data/spec/path_spec.rb

@@ -67,6 +67,26 @@ describe "Path" do
     end
   end
 
+  describe "#=~" do
+    let(:path) { FPM::Cookery::Path.new('/bar/baz/quux.txt') }
+
+    context "given a Regexp matching the path" do
+      it "returns the index of the beginning of the the match" do
+        expect(path =~ %r[/\w{4}\.\w{3}]).to eq(8)
+      end
+    end
+
+    context "given a non-Regexp argument" do
+      it "raises TypeError" do
+        expect { path =~ 'this' }.to raise_error do |error|
+          expect(error).to be_a(TypeError)
+          expect(error.message).to match(/type\s+mismatch/)
+        end
+      end
+    end
+
+  end
+
   describe "#mkdir" do
     it "creates the directory" do
       dir = Dir.mktmpdir

data/spec/recipe_spec.rb

@@ -1,23 +1,28 @@
 require 'spec_helper'
+require 'json'
+require 'fpm/cookery/book'
+require 'fpm/cookery/book_hook'
+require 'fpm/cookery/exceptions'
+require 'fpm/cookery/facts'
 require 'fpm/cookery/recipe'
 
-describe "Recipe" do
-  def stub_dir(dir, path)
-    value = path.nil? ? nil : FPM::Cookery::Path.new(path)
-    allow(config).to receive(dir).and_return(value)
-  end
-
-  let(:klass) do
-    Class.new(FPM::Cookery::Recipe)
-  end
-
-  let(:config) do
-    double('Config', :tmp_root => nil, :pkg_dir => nil, :cache_dir => nil).as_null_object
+describe "BaseRecipe" do
+  [:config, :filename].each do |method_name|
+    describe method_name.to_s do
+      it "informs the caller that it must be implemented at runtime" do
+        expect { FPM::Cookery::BaseRecipe.send(method_name) }.to raise_error do |error|
+          expect(error).to be_a(NotImplementedError)
+          expect(error.message).to match(/must be defined when recipe file is loaded/)
+        end
+      end
+    end
   end
+end
 
-  let(:recipe) do
-    klass.new(__FILE__, config)
-  end
+describe "Recipe" do
+  config_options = { :tmp_root => nil, :pkg_dir => nil, :cache_dir => nil,
+                     :hiera_config => nil }
+  include_context "recipe class", __FILE__, config_options
 
   it "sets the filename" do
     expect(recipe.filename.to_s).to eq(__FILE__)
@@ -31,15 +36,26 @@ describe "Recipe" do
     describe "with a relative filename path" do
       it "expands the workdir path" do
         filename = "spec/#{File.basename(__FILE__)}"
-        r = klass.new(filename, config)
+        r = recipe_klass.new
         expect(r.workdir.to_s).to eq(File.dirname(__FILE__))
       end
     end
   end
 
+  describe "#input" do
+    # Avoid Errno::ENOENT for recipe dir that no longer exists
+    before do
+      allow(config).to receive(:fetch).with(:input, nil).and_return([])
+    end
+
+    it "defaults to FPM::Cookery::Package::Dir" do
+      expect(recipe.input(config)).to be_a(FPM::Cookery::Package::Dir)
+    end
+  end
+
   describe "#source_handler" do
     it "returns the recipe's source handler" do
-      klass.class_eval do
+      recipe_klass.class_eval do
         source 'http://example.com/foo-1.0.tar.gz', :foo => 'bar'
       end
 
@@ -53,12 +69,18 @@ describe "Recipe" do
   def check_attribute(attr, value, expect = nil)
     expect ||= value
 
-    klass.send(attr, value)
+    recipe_klass.send(attr, value)
 
-    expect(klass.send(attr)).to eq(expect)
+    expect(recipe_klass.send(attr)).to eq(expect)
     expect(recipe.send(attr)).to eq(expect)
   end
 
+  describe '#rpm_dist' do
+    it 'can be set' do
+      check_attribute(:rpm_dist, 'el7')
+    end
+  end
+
   describe "#arch" do
     it "can be set" do
       check_attribute(:arch, 'i386')
@@ -205,18 +227,60 @@ describe "Recipe" do
     end
   end
 
+  describe "#hiera" do
+    before do
+      allow(config).to receive(:hiera_config).and_return("/probably/does/not/exist/pretty/sure/anyway")
+    end
+
+    it "raises an error when Hiera config file does not exist" do
+      expect { recipe_klass.hiera }.to raise_error do |error|
+        expect(error).to be_an(FPM::Cookery::Error::ExecutionFailure)
+        expect(error.message).to match(/Encountered error loading Hiera/)
+      end
+    end
+  end
+
+  describe "#applicator" do
+    context "given an attribute not set in the Hiera data file(s)" do
+      before do
+        allow(recipe_klass).to receive(:lookup).with(:source).and_return(nil)
+        allow(recipe_klass).to receive(:source).and_return('http://www.facsimile.co.uk')
+      end
+
+      it "returns `nil'" do
+        expect(recipe_klass.send(:applicator, :source)).to be_nil
+      end
+
+      it "does not call the provided block" do
+        expect { recipe_klass.send(:applicator, :source) { print "whoa" } }.not_to \
+          output("whoa").to_stdout
+      end
+    end
+
+    context "given an attribute set in the Hiera data file(s)" do
+      before do
+        allow(recipe_klass).to receive(:lookup).with(:name).and_return('J.J. Jingleheimer-Schmidt IV')
+      end
+
+      it "calls the provided block" do
+        expect { recipe_klass.send(:applicator, :name) { print "whoa" } }.to \
+          output("whoa").to_stdout
+      end
+    end
+  end
+
   def self.spec_recipe_attribute_list(name, list)
     class_eval %Q{
       describe "##{name}" do
         it "can be set" do
-          klass.class_eval do
+          recipe_klass.class_eval do
             #{name} "#{list[0]}"
             #{name} "#{list[1]}"
           end
-          expect(klass.#{name}.size).to eq(#{list.size})
+          expect(recipe_klass.#{name}.size).to eq(#{list.size})
           expect(recipe.#{name}.size).to eq(#{list.size})
-          expect(klass.#{name}[0]).to eq("#{list[0]}")
-          expect(klass.#{name}[1]).to eq("#{list[1]}")
+          expect(recipe_klass.#{name}[0]).to eq("#{list[0]}")
+          expect(recipe_klass.#{name}[1]).to eq("#{list[1]}")
           expect(recipe.#{name}[0]).to eq("#{list[0]}")
           expect(recipe.#{name}[1]).to eq("#{list[1]}")
         end
@@ -238,44 +302,44 @@ describe "Recipe" do
 
   describe ".source" do
     it "sets a source url" do
-      klass.class_eval do
+      recipe_klass.class_eval do
         source 'http://example.com/foo-1.0.tar.gz'
       end
 
-      expect(klass.source).to eq('http://example.com/foo-1.0.tar.gz')
-      expect(klass.new(__FILE__, config).source).to eq('http://example.com/foo-1.0.tar.gz')
+      expect(recipe_klass.source).to eq('http://example.com/foo-1.0.tar.gz')
+      expect(recipe_klass.new.source).to eq('http://example.com/foo-1.0.tar.gz')
     end
 
     describe "with specs" do
       it "sets specs" do
-        klass.class_eval do
+        recipe_klass.class_eval do
           source 'http://example.com/foo-1.0.tar.gz', :foo => 'bar'
         end
 
-        expect(klass.spec).to eq({:foo => 'bar'})
-        expect(klass.new(__FILE__, config).spec).to eq({:foo => 'bar'})
+        expect(recipe_klass.spec).to eq({:foo => 'bar'})
+        expect(recipe_klass.new.spec).to eq({:foo => 'bar'})
       end
     end
   end
 
   describe ".url" do
     it "sets a source type (homebrew compat)" do
-      klass.class_eval do
+      recipe_klass.class_eval do
         url 'http://example.com/foo-1.0.tar.gz'
       end
 
-      expect(klass.source).to eq('http://example.com/foo-1.0.tar.gz')
-      expect(klass.new(__FILE__, config).source).to eq('http://example.com/foo-1.0.tar.gz')
+      expect(recipe_klass.source).to eq('http://example.com/foo-1.0.tar.gz')
+      expect(recipe_klass.new.source).to eq('http://example.com/foo-1.0.tar.gz')
     end
 
     describe "with specs" do
       it "sets specs" do
-        klass.class_eval do
+        recipe_klass.class_eval do
           url 'http://example.com/foo-1.0.tar.gz', :foo => 'bar'
         end
 
-        expect(klass.spec).to eq({:foo => 'bar'})
-        expect(klass.new(__FILE__, config).spec).to eq({:foo => 'bar'})
+        expect(recipe_klass.spec).to eq({:foo => 'bar'})
+        expect(recipe_klass.new.spec).to eq({:foo => 'bar'})
       end
     end
   end
@@ -293,18 +357,18 @@ describe "Recipe" do
 
   describe "#local_path" do
     it "returns the path to the local source file" do
-      klass.class_eval do
+      recipe_klass.class_eval do
         source 'http://example.com/foo-1.0.tar.gz'
       end
 
-      expect(File.basename(klass.new(__FILE__, config).local_path.to_s)).to eq('foo-1.0.tar.gz')
+      expect(File.basename(recipe_klass.new.local_path.to_s)).to eq('foo-1.0.tar.gz')
     end
   end
 
   describe ".platforms" do
     describe "with a list of platforms" do
       it "allows platform specific settings" do
-        klass.class_eval do
+      recipe_klass.class_eval do
           def self.platform; :ubuntu; end
 
           vendor 'a'
@@ -314,13 +378,13 @@ describe "Recipe" do
           end
         end
 
-        expect(klass.new(__FILE__, config).vendor).to eq('b')
+        expect(recipe_klass.new.vendor).to eq('b')
       end
     end
 
     describe "with a single platform" do
       it "allows platform specific settings" do
-        klass.class_eval do
+        recipe_klass.class_eval do
           def self.platform; :ubuntu; end
 
           vendor 'a'
@@ -330,13 +394,13 @@ describe "Recipe" do
           end
         end
 
-        expect(klass.new(__FILE__, config).vendor).to eq('b')
+        expect(recipe_klass.new.vendor).to eq('b')
       end
     end
 
     describe "without a matching platform" do
       it "does not set platform specific stuff" do
-        klass.class_eval do
+        recipe_klass.class_eval do
           def self.platform; :centos; end
 
           vendor 'a'
@@ -346,7 +410,7 @@ describe "Recipe" do
           end
         end
 
-        expect(klass.new(__FILE__, config).vendor).to eq('a')
+        expect(recipe_klass.new.vendor).to eq('a')
       end
     end
   end
@@ -360,7 +424,7 @@ describe "Recipe" do
 
     describe "with a list of architectures" do
       it "allows arch specific settings" do
-        klass.class_eval do
+        recipe_klass.class_eval do
           vendor 'a'
 
           architectures [:i386, :x86_64] do
@@ -368,13 +432,13 @@ describe "Recipe" do
           end
         end
 
-        expect(klass.new(__FILE__, config).vendor).to eq('b')
+        expect(recipe_klass.new.vendor).to eq('b')
       end
     end
 
     describe "with a single architecture" do
       it "allows arch specific settings" do
-        klass.class_eval do
+        recipe_klass.class_eval do
           vendor 'a'
 
           architectures :x86_64 do
@@ -382,13 +446,13 @@ describe "Recipe" do
           end
         end
 
-        expect(klass.new(__FILE__, config).vendor).to eq('b')
+        expect(recipe_klass.new.vendor).to eq('b')
       end
     end
 
     describe "without a matching architecture" do
       it "does not set arch specific settings" do
-        klass.class_eval do
+        recipe_klass.class_eval do
           vendor 'a'
 
           architectures :i386 do
@@ -396,11 +460,16 @@ describe "Recipe" do
           end
         end
 
-        expect(klass.new(__FILE__, config).vendor).to eq('a')
+        expect(recipe_klass.new.vendor).to eq('a')
       end
     end
   end
 
+  describe ".platform" do
+    it 'matches the current platform from FPM::Cookery::Facts' do
+      expect(recipe_klass.platform).to eq(FPM::Cookery::Facts.platform)
+    end
+  end
 
   #############################################################################
   # Directories
@@ -531,25 +600,25 @@ describe "Recipe" do
 
   describe "#depends_all" do
     it "returns build_depends and depends package names" do
-      klass.depends [:pkg1, :pkg2]
-      klass.build_depends [:pkg3, :pkg4]
+      recipe_klass.depends [:pkg1, :pkg2]
+      recipe_klass.build_depends [:pkg3, :pkg4]
 
       expect([:pkg1, :pkg2, :pkg3, :pkg4].all? { |i|
-        klass.depends_all.member?(i) && recipe.depends_all.member?(i)
+        recipe_klass.depends_all.member?(i) && recipe.depends_all.member?(i)
       }).to eq(true)
     end
   end
 
   describe ".fpm_attributes" do
     it "returns hash object as default" do
-      expect(klass.fpm_attributes).to be_a(Hash)
+      expect(recipe_klass.fpm_attributes).to be_a(Hash)
     end
 
     it "returns same value from instance method with hash assignment" do
       expect(recipe.fpm_attributes).to include({})
 
-      klass.fpm_attributes[:rpm_user] = 'httpd'
-      klass.fpm_attributes[:deb_user] = 'apache'
+      recipe_klass.fpm_attributes[:rpm_user] = 'httpd'
+      recipe_klass.fpm_attributes[:deb_user] = 'apache'
 
       expect(recipe.fpm_attributes).to include({:rpm_user=>'httpd', :deb_user=>'apache'})
     end
@@ -557,9 +626,45 @@ describe "Recipe" do
     it "returns same value from instance method with argument assignment" do
       expect(recipe.fpm_attributes).to include({})
 
-      klass.fpm_attributes :rpm_user => 'httpd', :deb_user => 'apache'
+      recipe_klass.fpm_attributes :rpm_user => 'httpd', :deb_user => 'apache'
 
       expect(recipe.fpm_attributes).to include({:rpm_user=>'httpd', :deb_user=>'apache'})
     end
   end
+
+  describe "#to_json" do
+    it "returns a terse JSON-formatted string with recipe attributes" do
+      json = recipe.to_json
+      expect { JSON.load(json) }.not_to raise_error
+      expect(json.lines.to_a.length).to be == 1
+      expect(json).to match(/"name"/)
+    end
+  end
+
+  describe "#to_pretty_json" do
+    it "returns a multiline JSON-formatted string with recipe attributes" do
+      json = recipe.to_pretty_json
+      expect { JSON.load(json) }.not_to raise_error
+      expect(json.lines.to_a.length).to be > 1
+      expect(json).to match(/"name"/)
+    end
+  end
+
+  describe "#template" do
+    context "given an ERB template containing valid recipe attributes" do
+      it "formats the string with recipe attributes" do
+        formatted = recipe.template("<%= name %>")
+        expect(formatted).to be == recipe.name
+      end
+    end
+
+    context "given an ERB template containing invalid recipe attributes" do
+      it "raises an error" do
+        expect { recipe.template("<%= notarecipeattr %>") }.to raise_error do |error|
+          expect(error).to be_an(FPM::Cookery::Error::ExecutionFailure)
+          expect(error.message).to match(/no attribute.*notarecipeattr/)
+        end
+      end
+    end
+  end
 end

data/spec/source_integrity_check_spec.rb

@@ -3,14 +3,15 @@ require 'fpm/cookery/source_integrity_check'
 require 'fpm/cookery/recipe'
 
 describe "SourceIntegrityCheck" do
-  let(:recipe_class) do
-    Class.new(FPM::Cookery::Recipe) {
-      source 'http://example.com/foo.tar.gz'
-    }
+  config_options = { :hiera_config => nil }
+  include_context "recipe class", __FILE__, config_options do
+    let(:klass) do
+      Class.new(FPM::Cookery::Recipe) {
+        source 'http://example.com/foo.tar.gz'
+      }
+    end
   end
 
-  let(:config) { double('Config').as_null_object }
-  let(:recipe) { recipe_class.new(__FILE__, config) }
   let(:check) { FPM::Cookery::SourceIntegrityCheck.new(recipe) }
 
   before do