puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/pops/binder/binder_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+module BinderSpecModule
+  def factory()
+    Puppet::Pops::Binder::BindingsFactory
+  end
+
+  def injector(binder)
+    Puppet::Pops::Binder::Injector.new(binder)
+  end
+
+  def binder()
+    Puppet::Pops::Binder::Binder.new()
+  end
+
+  def test_layer_with_empty_bindings
+    factory.named_layer('test-layer', factory.named_bindings('test').model)
+  end
+end
+
+describe 'Binder' do
+  include BinderSpecModule
+
+  context 'when defining categories' do
+    it 'redefinition is not allowed' do
+      expect do
+        b = binder()
+        b.define_categories(factory.categories([]))
+        b.define_categories(factory.categories([]))
+      end.to raise_error(/Cannot redefine/)
+    end
+  end
+
+  context 'when defining layers' do
+    it 'they must be defined after categories' do
+      expect do
+        binder().define_layers(factory.layered_bindings(test_layer_with_empty_bindings))
+      end.to raise_error(/Categories must be defined first/)
+    end
+
+    it 'redefinition is not allowed' do
+      expect do
+        b = binder()
+        b.define_categories(factory.categories([]))
+        b.define_layers(factory.layered_bindings(test_layer_with_empty_bindings))
+        b.define_layers(factory.layered_bindings(test_layer_with_empty_bindings))
+      end.to raise_error(/Cannot redefine its content/)
+    end
+  end
+
+  context 'when defining categories and layers' do
+    it 'a binder should report being configured when both categories and layers have been defined' do
+      b = binder()
+      b.configured?().should == false
+      b.define_categories(factory.categories([]))
+      b.configured?().should == false
+      b.define_layers(factory.layered_bindings(test_layer_with_empty_bindings))
+      b.configured?().should == true
+    end
+  end
+end

data/spec/unit/pops/binder/bindings_checker_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/pops'
+
+describe 'The bindings checker' do
+
+  include PuppetSpec::Pops
+
+  Issues = Puppet::Pops::Binder::BinderIssues
+  Bindings = Puppet::Pops::Binder::Bindings
+  TypeFactory = Puppet::Pops::Types::TypeFactory
+  let (:acceptor) {  Puppet::Pops::Validation::Acceptor.new() }
+
+  let (:binding) { Bindings::Binding.new() }
+
+  let (:ok_binding) {
+    b = Bindings::Binding.new()
+    b.producer = Bindings::ConstantProducerDescriptor.new()
+    b.producer.value = 'some value'
+    b.type = TypeFactory.string()
+    b
+  }
+
+  def validate(binding)
+    Puppet::Pops::Binder::BindingsValidatorFactory.new().validator(acceptor).validate(binding)
+  end
+
+  def bindings(*args)
+    b = Bindings::Bindings.new()
+    b.bindings = args
+    b
+  end
+
+  def named_bindings(name, *args)
+    b = Bindings::NamedBindings.new()
+    b.name = name
+    b.bindings = args
+    b
+  end
+
+  def category(name, value)
+    b = Bindings::Category.new()
+    b.categorization = name
+    b.value = value
+    b
+  end
+
+  def categorized_bindings(bindings, *predicates)
+    b = Bindings::CategorizedBindings.new()
+    b.bindings = bindings
+    b.predicates = predicates
+    b
+  end
+
+  def layer(name, *bindings)
+    l = Bindings::NamedLayer.new()
+    l.name = name
+    l.bindings = bindings
+    l
+  end
+
+  def layered_bindings(*layers)
+    b = Bindings::LayeredBindings.new()
+    b.layers = layers
+    b
+  end
+
+  def array_multibinding()
+    b = Bindings::Multibinding.new()
+    b.producer = Bindings::ArrayMultibindProducerDescriptor.new()
+    b.type = TypeFactory.array_of_data()
+    b
+  end
+
+  def bad_array_multibinding()
+    b = array_multibinding()
+    b.type = TypeFactory.hash_of_data() # intentionally wrong!
+    b
+  end
+
+  def hash_multibinding()
+    b = Bindings::Multibinding.new()
+    b.producer = Bindings::HashMultibindProducerDescriptor.new()
+    b.type = TypeFactory.hash_of_data()
+    b
+  end
+
+  def bad_hash_multibinding()
+    b = hash_multibinding()
+    b.type = TypeFactory.array_of_data() # intentionally wrong!
+    b
+  end
+
+  it 'should complain about missing producer and type' do
+    validate(binding())
+    acceptor.should have_issue(Issues::MISSING_PRODUCER)
+    acceptor.should have_issue(Issues::MISSING_TYPE)
+  end
+
+  context 'when checking array multibinding' do
+    it 'should complain about non array producers' do
+      validate(bad_array_multibinding())
+      acceptor.should have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
+    end
+  end
+
+  context 'when checking hash multibinding' do
+    it 'should complain about non hash producers' do
+      validate(bad_hash_multibinding())
+      acceptor.should have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
+    end
+  end
+
+  context 'when checking bindings' do
+    it 'should not accept zero bindings' do
+      validate(bindings())
+      acceptor.should have_issue(Issues::MISSING_BINDINGS)
+    end
+
+    it 'should accept non-zero bindings' do
+      validate(bindings(ok_binding))
+      acceptor.errors_or_warnings?.should() == false
+    end
+
+    it 'should check contained bindings' do
+      validate(bindings(bad_array_multibinding()))
+      acceptor.should have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
+    end
+  end
+
+  context 'when checking named bindings' do
+    it 'should accept named bindings' do
+      validate(named_bindings('garfield', ok_binding))
+      acceptor.errors_or_warnings?.should() == false
+    end
+
+    it 'should not accept unnamed bindings' do
+      validate(named_bindings(nil, ok_binding))
+      acceptor.should have_issue(Issues::MISSING_BINDINGS_NAME)
+    end
+
+    it 'should do generic bindings check' do
+      validate(named_bindings('garfield'))
+      acceptor.should have_issue(Issues::MISSING_BINDINGS)
+    end
+  end
+
+  context 'when checking categorized bindings' do
+    it 'should accept non-zero predicates' do
+      validate(categorized_bindings([ok_binding], category('foo', 'bar')))
+      acceptor.errors_or_warnings?.should() == false
+    end
+
+    it 'should not accept zero predicates' do
+      validate(categorized_bindings([ok_binding]))
+      acceptor.should have_issue(Issues::MISSING_PREDICATES)
+    end
+
+    it 'should not accept predicates that has no categorization' do
+      validate(categorized_bindings([ok_binding], category(nil, 'bar')))
+      acceptor.should have_issue(Issues::MISSING_CATEGORIZATION)
+    end
+
+    it 'should not accept predicates that has no value' do
+      validate(categorized_bindings([ok_binding], category('foo', nil)))
+      acceptor.should have_issue(Issues::MISSING_CATEGORY_VALUE)
+    end
+
+    it 'should do generic bindings check' do
+      validate(categorized_bindings([], category('foo', 'bar')))
+      acceptor.should have_issue(Issues::MISSING_BINDINGS)
+    end
+  end
+
+  context 'when checking layered bindings' do
+    it 'should not accept zero layers' do
+      validate(layered_bindings())
+      acceptor.should have_issue(Issues::MISSING_LAYERS)
+    end
+
+    it 'should accept non-zero layers' do
+      validate(layered_bindings(layer('foo', named_bindings('bar', ok_binding))))
+      acceptor.errors_or_warnings?.should() == false
+    end
+
+    it 'should not accept unnamed layers' do
+      validate(layered_bindings(layer(nil, named_bindings('bar', ok_binding))))
+      acceptor.should have_issue(Issues::MISSING_LAYER_NAME)
+    end
+
+    it 'should accept layers without bindings' do
+      validate(layered_bindings(layer('foo')))
+      acceptor.should_not have_issue(Issues::MISSING_BINDINGS_IN_LAYER)
+    end
+  end
+end

data/spec/unit/pops/binder/bindings_composer_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'puppet_spec/pops'
+
+describe 'BinderComposer' do
+  include PuppetSpec::Pops
+
+  def config_dir(config_name)
+    my_fixture(config_name)
+  end
+
+  let(:acceptor)    { Puppet::Pops::Validation::Acceptor.new() }
+  let(:diag)        { Puppet::Pops::Binder::Config::DiagnosticProducer.new(acceptor) }
+  let(:issues)      { Puppet::Pops::Binder::Config::Issues }
+  let(:node)        { Puppet::Node.new('localhost') }
+  let(:compiler)    { Puppet::Parser::Compiler.new(node)}
+  let(:scope)       { Puppet::Parser::Scope.new(compiler) }
+  let(:parser)      { Puppet::Pops::Parser::Parser.new() }
+  let(:factory)     { Puppet::Pops::Binder::BindingsFactory }
+
+  before(:each) do
+    Puppet[:binder] = true
+  end
+
+  it 'should load default config if no config file exists' do
+    diagnostics = diag
+    composer = Puppet::Pops::Binder::BindingsComposer.new()
+    composer.compose(scope)
+  end
+
+  context "when loading a complete configuration with modules" do
+    let(:config_directory) { config_dir('ok') }
+
+    it 'should load everything without errors' do
+      Puppet.settings[:confdir] = config_directory
+      Puppet.settings[:modulepath] = File.join(config_directory, 'modules')
+
+      diagnostics = diag
+      composer = Puppet::Pops::Binder::BindingsComposer.new()
+      the_scope = scope
+      the_scope['fqdn'] = 'localhost'
+      the_scope['environment'] = 'production'
+      layered_bindings = composer.compose(scope)
+      # puts Puppet::Pops::Binder::BindingsModelDumper.new().dump(layered_bindings)
+      binder = Puppet::Pops::Binder::Binder.new()
+      # TODO: this is cheating, the categories should come from the composer/config
+      binder.define_categories(factory.categories([['node', 'localhost'], ['environment', 'production']]))
+      binder.define_layers(layered_bindings)
+      injector = Puppet::Pops::Binder::Injector.new(binder)
+
+      expect(injector.lookup(scope, 'awesome_x')).to be == 'golden'
+      expect(injector.lookup(scope, 'good_x')).to be == 'golden'
+      expect(injector.lookup(scope, 'rotten_x')).to be == nil
+      expect(injector.lookup(scope, 'the_meaning_of_life')).to be == 42
+      expect(injector.lookup(scope, 'has_funny_hat')).to be == 'the pope'
+      expect(injector.lookup(scope, 'all your base')).to be == 'are belong to us'
+      expect(injector.lookup(scope, 'env_meaning_of_life')).to be == 'production thinks it is 42'
+      expect(injector.lookup(scope, '::quick::brown::fox')).to be == 'echo: quick brown fox'
+      expect(injector.lookup(scope, 'echo::common')).to be == 'echo... awesome/common'
+      expect(injector.lookup(scope, 'echo::localhost')).to be == 'echo... awesome/localhost'
+    end
+  end
+
+  context "when loading a configuration with hiera1 hiera.yaml" do
+    let(:config_directory) { config_dir('hiera1config') }
+
+    it 'should load without errors by skipping the hiera.yaml' do
+      Puppet.settings[:confdir] = config_directory
+      Puppet.settings[:modulepath] = File.join(config_directory, 'modules')
+
+      diagnostics = diag
+      composer = Puppet::Pops::Binder::BindingsComposer.new()
+      the_scope = scope
+      the_scope['fqdn'] = 'localhost'
+      the_scope['environment'] = 'production'
+      layered_bindings = composer.compose(scope)
+      # puts Puppet::Pops::Binder::BindingsModelDumper.new().dump(layered_bindings)
+      binder = Puppet::Pops::Binder::Binder.new()
+      # TODO: this is cheating, the categories should come from the composer/config
+      binder.define_categories(factory.categories([['node', 'localhost'], ['environment', 'production']]))
+      binder.define_layers(layered_bindings)
+      injector = Puppet::Pops::Binder::Injector.new(binder)
+
+      expect(injector.lookup(scope, 'the_meaning_of_life')).to be == 300
+    end
+  end
+
+  # TODO: test error conditions (see BinderConfigChecker for what to test)
+
+end

data/spec/unit/pops/binder/bindings_validator_factory_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe 'The bindings validator factory' do
+  let(:factory) {  Puppet::Pops::Binder::BindingsValidatorFactory.new() }
+
+  it 'should instantiate a BindingsValidatorFactory' do
+    factory.class.should == Puppet::Pops::Binder::BindingsValidatorFactory
+  end
+
+  it 'should produce label_provider of class BindingsLabelProvider' do
+    factory.label_provider.class.should == Puppet::Pops::Binder::BindingsLabelProvider
+  end
+
+  it 'should produce validator of class BindingsChecker' do
+    factory.validator(Puppet::Pops::Validation::Acceptor.new()).class.should == Puppet::Pops::Binder::BindingsChecker
+  end
+end

data/spec/unit/pops/binder/config/binder_config_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/pops'
+
+describe 'BinderConfig' do
+  include PuppetSpec::Pops
+
+  let(:acceptor)    { Puppet::Pops::Validation::Acceptor.new() }
+  let(:diag)        { Puppet::Pops::Binder::Config::DiagnosticProducer.new(acceptor) }
+  let(:issues)      { Puppet::Pops::Binder::Config::Issues }
+
+  it 'should load default config if no config file exists' do
+    diagnostics = diag
+    config = Puppet::Pops::Binder::Config::BinderConfig.new(diagnostics)
+    expect(acceptor.errors?()).to be == false
+    expect(config.layering_config[0]['name']).to    be == 'site'
+    expect(config.layering_config[0]['include']).to be == ['confdir-hiera:/', 'confdir:/default?optional']
+    expect(config.layering_config[1]['name']).to    be == 'modules'
+    expect(config.layering_config[1]['include']).to be == ['module-hiera:/*/', 'module:/*::default']
+
+    expect(config.categorization.is_a?(Array)).to be == true
+    expect(config.categorization.size).to be == 4
+    expect(config.categorization[0][0]).to be == 'node'
+    expect(config.categorization[1][0]).to be == 'osfamily'
+    expect(config.categorization[2][0]).to be == 'environment'
+    expect(config.categorization[3][0]).to be == 'common'
+  end
+
+  it 'should load binder_config.yaml if it exists in confdir)' do
+    Puppet::Pops::Binder::Config::BinderConfig.any_instance.stubs(:confdir).returns(my_fixture("/ok/"))
+    config = Puppet::Pops::Binder::Config::BinderConfig.new(diag)
+    expect(acceptor.errors?()).to be == false
+    expect(config.layering_config[0]['name']).to    be == 'site'
+    expect(config.layering_config[0]['include']).to be == 'confdir-hiera:/'
+    expect(config.layering_config[1]['name']).to    be == 'modules'
+    expect(config.layering_config[1]['include']).to be == 'module-hiera:/*/'
+    expect(config.layering_config[1]['exclude']).to be == 'module-hiera:/bad/'
+
+    expect(config.categorization.is_a?(Array)).to be == true
+    expect(config.categorization.size).to be == 3
+    expect(config.categorization[0][0]).to be == 'node'
+    expect(config.categorization[1][0]).to be == 'environment'
+    expect(config.categorization[2][0]).to be == 'common'
+  end
+
+  # TODO: test error conditions (see BinderConfigChecker for what to test)
+
+end

data/spec/unit/pops/binder/hiera2/bindings_provider_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/pops'
+
+describe 'The hiera2 bindings provider' do
+
+  include PuppetSpec::Pops
+
+  def config_dir(config_name)
+    File.dirname(my_fixture("#{config_name}/hiera.yaml"))
+  end
+
+  before(:each) do
+    Puppet[:binder] = true
+  end
+
+  context 'when loading ok bindings' do
+
+    let(:node) { 'node.example.com' }
+    let(:acceptor) {  Puppet::Pops::Validation::Acceptor.new() }
+    let(:scope) { s = Puppet::Parser::Scope.new_for_test_harness(node); s['a'] = '42'; s['node'] = node; s }
+    let(:module_dir) { config_dir('ok') }
+    let(:node_binder) {  b = Puppet::Pops::Binder::Binder.new(); b.define_categories(Puppet::Pops::Binder::BindingsFactory.categories(['node', node])); b }
+    let(:bindings) { Puppet::Pops::Binder::Hiera2::BindingsProvider.new('test', module_dir, acceptor).load_bindings(scope) }
+    let(:test_layer_with_bindings) { bindings }
+
+    it 'should load and validate OK bindings' do
+      Puppet::Pops::Binder::BindingsValidatorFactory.new().validator(acceptor).validate(bindings)
+      acceptor.errors_or_warnings?.should() == false
+    end
+
+    it 'should contain the expected effective categories' do
+      bindings.effective_categories.categories.collect {|c| [c.categorization, c.value] }.should == [['node', 'node.example.com']]
+    end
+
+    it 'should produce the expected bindings model' do
+      bindings.class.should() == Puppet::Pops::Binder::Bindings::ContributedBindings
+      bindings.bindings.bindings.each do |cat|
+        cat.class.should() == Puppet::Pops::Binder::Bindings::CategorizedBindings
+        cat.predicates.length.should() == 1
+        cat.predicates[0].categorization.should() == 'node'
+        cat.predicates[0].value.should() == node
+        cat.bindings.each do |b|
+          b.class.should() == Puppet::Pops::Binder::Bindings::Binding
+          ['a_number', 'a_string', 'an_eval', 'an_eval2', 'a_json_number', 'a_json_string', 'a_json_eval',
+            'a_json_eval2', 'a_json_hash', 'a_json_array'].index(b.name).should() >= 0
+          b.producer.class.should() == Puppet::Pops::Binder::Bindings::EvaluatingProducerDescriptor if b.name == 'an_eval'
+        end
+      end
+    end
+
+    it 'should make the injector lookup expected constants' do
+      node_binder.define_layers(Puppet::Pops::Binder::BindingsFactory.layered_bindings(test_layer_with_bindings))
+      injector = Puppet::Pops::Binder::Injector.new(node_binder)
+
+      injector.lookup(scope, 'a_number').should == 42
+      injector.lookup(scope, 'a_string').should == 'forty two'
+      injector.lookup(scope, 'a_json_number').should == 142
+      injector.lookup(scope, 'a_json_string').should == 'one hundred and forty two'
+      expect(injector.lookup(scope, "a_json_array")).to be == ["a", "b", 100]
+      expect(injector.lookup(scope, "a_json_hash")).to be == {"a"  => 1, "b" => 2}
+    end
+
+    it 'should make the injector lookup and evaluate expressions' do
+      node_binder.define_layers(Puppet::Pops::Binder::BindingsFactory.layered_bindings(test_layer_with_bindings))
+      injector = Puppet::Pops::Binder::Injector.new(node_binder)
+
+      injector.lookup(scope, 'an_eval').should == 'the answer from "yaml" is 42.'
+      injector.lookup(scope, 'an_eval2').should == "the answer\nfrom \\\"yaml\\\" is 42 and $a"
+      injector.lookup(scope, 'a_json_eval').should == 'the answer from "json" is 42 and ${a}.'
+      injector.lookup(scope, 'a_json_eval2').should == "the answer\nfrom \\\"json\\\" is 42 and $a"
+    end
+  end
+end