hiera-puppet 0.3.0 → 1.0.0rc2

data/lib/puppet/parser/functions/hiera_array.rb

@@ -1,36 +1,8 @@
 module Puppet::Parser::Functions
-    newfunction(:hiera_array, :type => :rvalue) do |*args|
-        if args[0].is_a?(Array)
-            args = args[0]
-        end
-
-        key = args[0]
-        default = args[1]
-        override = args[2]
-
-        configfile = File.join([File.dirname(Puppet.settings[:config]), "hiera.yaml"])
-
-        raise(Puppet::ParseError, "Hiera config file #{configfile} not readable") unless File.exist?(configfile)
-        raise(Puppet::ParseError, "You need rubygems to use Hiera") unless Puppet.features.rubygems?
-
-        require 'hiera'
-        require 'hiera/scope'
-
-        config = YAML.load_file(configfile)
-        config[:logger] = "puppet"
-
-        hiera = Hiera.new(:config => config)
-
-        if self.respond_to?("[]")
-            hiera_scope = self
-        else
-            hiera_scope = Hiera::Scope.new(self)
-        end
-
-        answer = hiera.lookup(key, default, hiera_scope, override, :array)
-
-        raise(Puppet::ParseError, "Could not find data item #{key} in any Hiera data file and no default supplied") if answer.empty?
-
-        answer
-    end
+  newfunction(:hiera_array, :type => :rvalue) do |*args|
+    require 'hiera_puppet'
+    key, default, override = HieraPuppet.parse_args(args)
+    HieraPuppet.lookup(key, default, self, override, :array)
+  end
 end
+

data/lib/puppet/parser/functions/hiera_hash.rb

@@ -1,36 +1,8 @@
 module Puppet::Parser::Functions
-    newfunction(:hiera_hash, :type => :rvalue) do |*args|
-        if args[0].is_a?(Array)
-            args = args[0]
-        end
-
-        key = args[0]
-        default = args[1]
-        override = args[2]
-
-        configfile = File.join([File.dirname(Puppet.settings[:config]), "hiera.yaml"])
-
-        raise(Puppet::ParseError, "Hiera config file #{configfile} not readable") unless File.exist?(configfile)
-        raise(Puppet::ParseError, "You need rubygems to use Hiera") unless Puppet.features.rubygems?
-
-        require 'hiera'
-        require 'hiera/scope'
-
-        config = YAML.load_file(configfile)
-        config[:logger] = "puppet"
-
-        hiera = Hiera.new(:config => config)
-
-        if self.respond_to?("{}")
-            hiera_scope = self
-        else
-            hiera_scope = Hiera::Scope.new(self)
-        end
-
-        answer = hiera.lookup(key, default, hiera_scope, override, :hash)
-
-        raise(Puppet::ParseError, "Could not find data item #{key} in any Hiera data file and no default supplied") if answer.empty?
-
-        answer
-    end
+  newfunction(:hiera_hash, :type => :rvalue) do |*args|
+    require 'hiera_puppet'
+    key, default, override = HieraPuppet.parse_args(args)
+    HieraPuppet.lookup(key, default, self, override, :hash)
+  end
 end
+

data/lib/puppet/parser/functions/hiera_include.rb

@@ -1,37 +1,11 @@
 module Puppet::Parser::Functions
-    newfunction(:hiera_include) do |*args|
-        if args[0].is_a?(Array)
-            args = args[0]
-        end
-
-        key = args[0]
-        default = args[1]
-        override = args[2]
-
-        configfile = File.join([File.dirname(Puppet.settings[:config]), "hiera.yaml"])
-
-        raise(Puppet::ParseError, "Hiera config file #{configfile} not readable") unless File.exist?(configfile)
-        raise(Puppet::ParseError, "You need rubygems to use Hiera") unless Puppet.features.rubygems?
-
-        require 'hiera'
-        require 'hiera/scope'
-
-        config = YAML.load_file(configfile)
-        config[:logger] = "puppet"
-
-        hiera = Hiera.new(:config => config)
-
-        if self.respond_to?("[]")
-            hiera_scope = self
-        else
-            hiera_scope = Hiera::Scope.new(self)
-        end
-
-        answer = hiera.lookup(key, default, hiera_scope, override, :array)
-
-        raise(Puppet::ParseError, "Could not find data item #{key} in any Hiera data file and no default supplied") if answer.empty?
-
-        method = Puppet::Parser::Functions.function(:include)
-        send(method, answer)
-    end
+  newfunction(:hiera_include) do |*args|
+    require 'hiera_puppet'
+    key, default, override = HieraPuppet.parse_args(args)
+    answer = HieraPuppet.lookup(key, default, self, override, :array)
+
+    method = Puppet::Parser::Functions.function(:include)
+    send(method, answer)
+  end
 end
+

data/spec/spec_helper.rb

@@ -1,20 +1,14 @@
-$:.insert(0, File.join([File.dirname(__FILE__), "..", "..", "lib"]))
+$LOAD_PATH.insert(0, File.join([File.dirname(__FILE__), "..", "..", "lib"]))
 
 require 'rubygems'
 require 'rspec'
+require 'rspec/mocks'
+require 'hiera'
+require 'puppetlabs_spec_helper/module_spec_helper'
+require 'hiera_puppet'
 require 'hiera/backend/puppet_backend'
 require 'hiera/scope'
-require 'rspec/mocks'
-require 'mocha'
 
 RSpec.configure do |config|
-    config.mock_with :mocha
+  config.mock_with :mocha
 end
-
-class Puppet
-    class Parser
-        class Functions
-        end
-    end
-end
-

data/spec/unit/hiera/backend/puppet_backend_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+class Hiera
+  module Backend
+    describe Puppet_backend do
+      before do
+        Hiera.stubs(:warn)
+        Hiera.stubs(:debug)
+        Backend.stubs(:datasources).yields([])
+        Puppet::Parser::Functions.stubs(:function).with(:include)
+
+        @mockresource = mock
+        @mockresource.stubs(:name).returns("ntp::config")
+
+        @mockscope = mock
+        @mockscope.stubs(:resource).returns(@mockresource)
+
+        @scope = Scope.new(@mockscope)
+
+        @backend = Puppet_backend.new
+      end
+
+      describe "#hierarchy" do
+        it "should use the configured datasource" do
+          Config.expects("[]").with(:puppet).returns({:datasource => "rspec"})
+          Config.expects("[]").with(:hierarchy)
+
+          ["ntp", "ntp::config"].each do |klass|
+            Backend.expects(:parse_string).with(klass, @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns(klass)
+          end
+
+          @backend.hierarchy(@scope, nil).should == ["rspec::ntp::config", "rspec::ntp", "ntp::config::rspec", "ntp::rspec"]
+        end
+
+        it "should not include empty class names" do
+          Config.expects("[]").with(:puppet).returns({:datasource => "rspec"})
+          Config.expects("[]").with(:hierarchy).returns(["%{foo}", "common"])
+
+          Backend.expects(:parse_string).with("common", @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns("common")
+          Backend.expects(:parse_string).with("%{foo}", @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns("")
+
+          @backend.hierarchy(@scope, nil).should == ["rspec::common", "ntp::config::rspec", "ntp::rspec"]
+        end
+
+        it "should allow for an override data source" do
+          Config.expects("[]").with(:puppet).returns({:datasource => "rspec"})
+          Config.expects("[]").with(:hierarchy)
+
+          ["ntp", "ntp::config"].each do |klass|
+            Backend.expects(:parse_string).with(klass, @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns(klass)
+          end
+
+          @backend.hierarchy(@scope, "override").should == ["rspec::override", "rspec::ntp::config", "rspec::ntp", "ntp::config::rspec", "ntp::rspec"]
+        end
+      end
+
+      describe "#lookup" do
+        it "should attempt to load data from unincluded classes" do
+          Backend.expects(:parse_answer).with("rspec", @scope).returns("rspec")
+
+          catalog = mock
+          catalog.expects(:classes).returns([])
+
+          @scope.expects(:catalog).returns(catalog)
+          @scope.expects(:function_include).with("rspec")
+          @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec")
+
+          @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec"])
+          @backend.lookup("key", @scope, nil, nil).should == "rspec"
+        end
+
+        it "should not load loaded classes" do
+          Backend.expects(:parse_answer).with("rspec", @scope).returns("rspec")
+          catalog = mock
+          catalog.expects(:classes).returns(["rspec"])
+          @mockscope.expects(:catalog).returns(catalog)
+          @mockscope.expects(:function_include).never
+          @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec")
+
+          @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec"])
+          @backend.lookup("key", @scope, nil, nil).should == "rspec"
+        end
+
+        it "should return the first found data" do
+          Backend.expects(:parse_answer).with("rspec", @scope).returns("rspec")
+          catalog = mock
+          catalog.expects(:classes).returns(["rspec", "override"])
+          @mockscope.expects(:catalog).returns(catalog)
+          @mockscope.expects(:function_include).never
+          @mockscope.expects(:lookupvar).with("override::key").returns("rspec")
+          @mockscope.expects(:lookupvar).with("rspec::key").never
+
+          @backend.expects(:hierarchy).with(@scope, "override").returns(["override", "rspec"])
+          @backend.lookup("key", @scope, "override", nil).should == "rspec"
+        end
+
+        it "should return an array of found data for array searches" do
+          Backend.expects(:parse_answer).with("rspec::key", @scope).returns("rspec::key")
+          Backend.expects(:parse_answer).with("test::key", @scope).returns("test::key")
+          catalog = mock
+          catalog.expects(:classes).returns(["rspec", "test"])
+          @mockscope.expects(:catalog).returns(catalog)
+          @mockscope.expects(:function_include).never
+          @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec::key")
+          @mockscope.expects(:lookupvar).with("test::key").returns("test::key")
+
+          @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec", "test"])
+          @backend.lookup("key", @scope, nil, :array).should == ["rspec::key", "test::key"]
+        end
+
+
+        it "should return a hash of found data for hash searches" do
+          Backend.expects(:parse_answer).with("rspec::key", @scope).returns({'rspec'=>'key'})
+          Backend.expects(:parse_answer).with("test::key", @scope).returns({'test'=>'key'})
+          catalog = mock
+          catalog.expects(:classes).returns(["rspec", "test"])
+          @mockscope.expects(:catalog).returns(catalog)
+          @mockscope.expects(:function_include).never
+          @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec::key")
+          @mockscope.expects(:lookupvar).with("test::key").returns("test::key")
+
+          @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec", "test"])
+          @backend.lookup("key", @scope, nil, :hash).should == {'rspec'=>'key', 'test'=>'key'}
+        end
+
+        it "should return a merged hash of found data for hash searches" do
+          Backend.expects(:parse_answer).with("rspec::key", @scope).returns({'rspec'=>'key', 'common'=>'rspec'})
+          Backend.expects(:parse_answer).with("test::key", @scope).returns({'test'=>'key', 'common'=>'rspec'})
+          catalog = mock
+          catalog.expects(:classes).returns(["rspec", "test"])
+          @mockscope.expects(:catalog).returns(catalog)
+          @mockscope.expects(:function_include).never
+          @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec::key")
+          @mockscope.expects(:lookupvar).with("test::key").returns("test::key")
+
+          @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec", "test"])
+          @backend.lookup("key", @scope, nil, :hash).should == {'rspec'=>'key', 'common'=>'rspec', 'test'=>'key'}
+        end
+      end
+    end
+  end
+end
+

data/spec/unit/hiera/scope_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+class Hiera
+  describe Scope do
+    describe "#initialize" do
+      it "should store the supplied puppet scope" do
+        real = {}
+        scope = Scope.new(real)
+        scope.real.should == real
+      end
+    end
+
+    describe "#[]" do
+      it "should treat '' as nil" do
+        real = mock
+        real.expects(:lookupvar).with("foo").returns("")
+
+        scope = Scope.new(real)
+        scope["foo"].should == nil
+      end
+
+      it "sould return found data" do
+        real = mock
+        real.expects(:lookupvar).with("foo").returns("bar")
+
+        scope = Scope.new(real)
+        scope["foo"].should == "bar"
+      end
+
+      it "should get calling_class and calling_module from puppet scope" do
+        real = mock
+        resource = mock
+        resource.expects(:name).returns("Foo::Bar").twice
+
+        real.expects(:resource).returns(resource).twice
+
+        scope = Scope.new(real)
+        scope["calling_class"].should == "foo::bar"
+        scope["calling_module"].should == "foo"
+      end
+    end
+
+    describe "#include?" do
+      it "should correctly report missing data" do
+        real = mock
+        real.expects(:lookupvar).with("foo").returns("")
+
+        scope = Scope.new(real)
+        scope.include?("foo").should == false
+      end
+
+      it "should always return true for calling_class and calling_module" do
+        real = mock
+        real.expects(:lookupvar).with("calling_class").never
+        real.expects(:lookupvar).with("calling_module").never
+
+        scope = Scope.new(real)
+        scope.include?("calling_class").should == true
+        scope.include?("calling_module").should == true
+      end
+    end
+  end
+end
+

data/spec/unit/hiera_puppet_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe 'HieraPuppet' do
+  describe 'HieraPuppet#hiera_config' do
+    let(:hiera_config_data) do
+      { :backend => 'yaml' }
+    end
+
+    context "when the hiera_config_file exists" do
+      before do
+        Hiera::Config.expects(:load).returns(hiera_config_data)
+        HieraPuppet.expects(:hiera_config_file).returns(true)
+      end
+
+      it "should return a configuration hash" do
+        expected_results = {
+          :backend => 'yaml',
+          :logger  => 'puppet'
+        }
+        HieraPuppet.send(:hiera_config).should == expected_results
+      end
+    end
+
+    context "when the hiera_config_file does not exist" do
+      before do
+        Hiera::Config.expects(:load).never
+        HieraPuppet.expects(:hiera_config_file).returns(nil)
+      end
+
+      it "should return a configuration hash" do
+        HieraPuppet.send(:hiera_config).should == { :logger => 'puppet' }
+      end
+    end
+  end
+
+  describe 'HieraPuppet#hiera_config_file' do
+    it "should return nil when we cannot derive the hiera config file form Puppet.settings" do
+      begin
+        Puppet.settings[:hiera_config] = nil
+      rescue ArgumentError => detail
+        raise unless detail.message =~ /unknown configuration parameter/
+      end
+      HieraPuppet.send(:hiera_config_file).should be_nil
+    end
+
+    it "should use Puppet.settings[:hiera_config] as the hiera config file" do
+      begin
+        Puppet.settings[:hiera_config] = "/dev/null/my_hiera.yaml"
+      rescue ArgumentError => detail
+        raise unless detail.message =~ /unknown configuration parameter/
+        pending("This example does not apply to Puppet #{Puppet.version} because it does not have this setting")
+      end
+
+      File.stubs(:exist?).with("/dev/null/my_hiera.yaml").returns(true)
+      HieraPuppet.send(:hiera_config_file).should == '/dev/null/my_hiera.yaml'
+    end
+
+    it "should use Puppet.settings[:confdir] as the base directory when hiera_config is not set" do
+      begin
+        Puppet.settings[:hiera_config] = nil
+      rescue ArgumentError => detail
+        raise unless detail.message =~ /unknown configuration parameter/
+      end
+      Puppet.settings[:confdir] = "/dev/null/puppet"
+      File.stubs(:exist?).with('/dev/null/puppet/hiera.yaml').returns(true)
+
+      HieraPuppet.send(:hiera_config_file).should == '/dev/null/puppet/hiera.yaml'
+    end
+  end
+
+  describe 'HieraPuppet#lookup' do
+    let(:scope) { PuppetlabsSpec::PuppetSeams.parser_scope }
+
+    it "should return the value from Hiera" do
+      Hiera.any_instance.stubs(:lookup).returns('8080')
+      HieraPuppet.lookup('port', nil, scope, nil, :priority).should == '8080'
+
+      Hiera.any_instance.stubs(:lookup).returns(['foo', 'bar'])
+      HieraPuppet.lookup('ntpservers', nil, scope, nil, :array).should == ['foo', 'bar']
+
+      Hiera.any_instance.stubs(:lookup).returns({'uid' => '1000'})
+      HieraPuppet.lookup('user', nil, scope, nil, :hash).should == {'uid' => '1000'}
+    end
+
+    it "should raise a useful error when the answer is nil" do
+      Hiera.any_instance.stubs(:lookup).returns(nil)
+      expect do
+        HieraPuppet.lookup('port', nil, scope, nil, :priority)
+      end.to raise_error(Puppet::ParseError,
+        /Could not find data item port in any Hiera data file and no default supplied/)
+    end
+  end
+
+  describe 'HieraPuppet#parse_args' do
+    it 'should return a 3 item array' do
+      args = ['foo', '8080', nil, nil]
+      HieraPuppet.parse_args(args).should == ['foo', '8080', nil]
+    end
+
+    it 'should raise a useful error when no key is supplied' do
+      expect { HieraPuppet.parse_args([]) }.to raise_error(Puppet::ParseError,
+        /Please supply a parameter to perform a Hiera lookup/)
+    end
+  end
+end