puppet 4.0.0 → 4.5.0

data/spec/unit/pops/loaders/static_loader_spec.rb

@@ -46,7 +46,98 @@ describe 'the static loader' do
     end
   end
 
+  context 'provides access to resource types built into puppet' do
+    let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
+
+    %w{
+      Auegas
+      Component
+      Computer
+      Cron
+      Exec
+      File
+      Filebucket
+      Group
+      Host
+      Interface
+      K5login
+      Macauthorization
+      Mailalias
+      Maillist
+      Mcx
+      Mount
+      Nagios_command
+      Nagios_contact
+      Nagios_contactgroup
+      Nagios_host
+      Nagios_hostdependency
+      Nagios_hostescalation
+      Nagios_hostescalation
+      Nagios_hostgroup
+      Nagios_service
+      Nagios_servicedependency
+      Nagios_serviceescalation
+      Nagios_serviceextinfo
+      Nagios_servicegroup
+      Nagios_timeperiod
+      Notify
+      Package
+      Resources
+      Router
+      Schedule
+      Scheduled_task
+      Selboolean
+      Selmodule
+      Service
+      Ssh_authorized_key
+      Sshkey
+      Stage
+      Tidy
+      User
+      Vlan
+      Whit
+      Yumrepo
+      Zfs
+      Zone
+      Zpool
+    }.each do |name |
+      it "such that #{name} is available" do
+        expect(loader.load(:type, name.downcase)).to be_the_type(resource_type(name))
+      end
+    end
+  end
+
+  context 'provides access to app-management specific resource types built into puppet' do
+    before(:each) { Puppet[:app_management] = true }
+    after(:each) { Puppet[:app_management] = false }
+
+    let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
+
+    %w{Node}.each do |name|
+      it "such that #{name} is avaiable" do
+        expect(loader.load(:type, name.downcase)).to be_the_type(resource_type(name))
+      end
+    end
+  end
+
   def typed_name(type, name)
     Puppet::Pops::Loader::Loader::TypedName.new(type, name)
   end
-end
+
+  def resource_type(name)
+    Puppet::Pops::Types::TypeFactory.resource(name)
+  end
+
+  matcher :be_the_type do |type|
+    calc = Puppet::Pops::Types::TypeCalculator.new
+
+    match do |actual|
+      calc.assignable?(actual, type) && calc.assignable?(type, actual)
+    end
+
+    failure_message do |actual|
+      "expected #{type.to_s}, but was #{actual.to_s}"
+    end
+  end
+
+end

data/spec/unit/pops/lookup/interpolation_spec.rb

@@ -0,0 +1,313 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet'
+require 'puppet/data_providers/hiera_config'
+require 'puppet/data_providers/hiera_interpolate'
+
+module Puppet::Pops
+describe 'Puppet::Pops::Lookup::Interpolation' do
+
+  let(:interpolator) { Class.new { include Lookup::Interpolation }.new }
+  let(:scope) { {} }
+  let(:lookup_invocation) { Lookup::Invocation.new(scope, {}, {}, nil) }
+
+  def expect_lookup(*keys)
+    keys.each { |key| Lookup.expects(:lookup).with(key, nil, '', true, nil, lookup_invocation).returns(data[key]) }
+  end
+
+  context 'when interpolating nested data' do
+    let(:nested_hash) { {'a' => {'aa' => "%{alias('aaa')}"}} }
+
+    let(:data) {
+      {
+        'aaa' => {'b' => {'bb' => "%{alias('bbb')}"}},
+        'bbb' => ["%{alias('ccc')}"],
+        'ccc' => 'text'
+      }
+    }
+
+    it 'produces a nested hash with arrays from nested aliases with hashes and arrays' do
+      expect_lookup('aaa', 'bbb', 'ccc')
+      expect(interpolator.interpolate(nested_hash, lookup_invocation, true)).to eq('a' => {'aa' => {'b' => {'bb' => ['text']}}})
+    end
+  end
+
+  context 'when there are empty interpolations %{} in data' do
+
+    let(:empty_interpolation) { 'clown%{}shoe' }
+    let(:empty_interpolation_as_escape) { 'clown%%{}{shoe}s' }
+    let(:only_empty_interpolation) { '%{}' }
+    let(:empty_namespace) { '%{::}' }
+    let(:whitespace1) { '%{ :: }' }
+    let(:whitespace2) { '%{   }' }
+
+    it 'should produce an empty string for the interpolation' do
+      expect(interpolator.interpolate(empty_interpolation, lookup_invocation, true)).to eq('clownshoe')
+    end
+
+    it 'the empty interpolation can be used as an escape mechanism' do
+      expect(interpolator.interpolate(empty_interpolation_as_escape, lookup_invocation, true)).to eq('clown%{shoe}s')
+    end
+
+    it 'the value can consist of only an empty escape' do
+      expect(interpolator.interpolate(only_empty_interpolation, lookup_invocation, true)).to eq('')
+    end
+
+    it 'the value can consist of an empty namespace %{::}' do
+      expect(interpolator.interpolate(empty_namespace, lookup_invocation, true)).to eq('')
+    end
+
+    it 'the value can consist of whitespace %{ :: }' do
+      expect(interpolator.interpolate(whitespace1, lookup_invocation, true)).to eq('')
+    end
+
+    it 'the value can consist of whitespace %{  }' do
+      expect(interpolator.interpolate(whitespace2, lookup_invocation, true)).to eq('')
+    end
+  end
+
+  context 'when there are quoted empty interpolations %{} in data' do
+
+    let(:empty_interpolation) { 'clown%{""}shoe' }
+    let(:empty_interpolation_as_escape) { 'clown%%{""}{shoe}s' }
+    let(:only_empty_interpolation) { '%{""}' }
+    let(:empty_namespace) { '%{"::"}' }
+    let(:whitespace1) { '%{ "::" }' }
+    let(:whitespace2) { '%{ ""  }' }
+
+    it 'should produce an empty string for the interpolation' do
+      expect(interpolator.interpolate(empty_interpolation, lookup_invocation, true)).to eq('clownshoe')
+    end
+
+    it 'the empty interpolation can be used as an escape mechanism' do
+      expect(interpolator.interpolate(empty_interpolation_as_escape, lookup_invocation, true)).to eq('clown%{shoe}s')
+    end
+
+    it 'the value can consist of only an empty escape' do
+      expect(interpolator.interpolate(only_empty_interpolation, lookup_invocation, true)).to eq('')
+    end
+
+    it 'the value can consist of an empty namespace %{"::"}' do
+      expect(interpolator.interpolate(empty_namespace, lookup_invocation, true)).to eq('')
+    end
+
+    it 'the value can consist of whitespace %{ "::" }' do
+      expect(interpolator.interpolate(whitespace1, lookup_invocation, true)).to eq('')
+    end
+
+    it 'the value can consist of whitespace %{ "" }' do
+      expect(interpolator.interpolate(whitespace2, lookup_invocation, true)).to eq('')
+    end
+  end
+
+
+  context 'when using dotted keys' do
+    let(:data) {
+      {
+        'a.b' => '(lookup) a dot b',
+        'a' => {
+          'd' => '(lookup) a dot d is a hash entry',
+          'd.x' => '(lookup) a dot d.x is a hash entry',
+          'd.z' => {
+            'g' => '(lookup) a dot d.z dot g is a hash entry'}
+        },
+        'a.x' => {
+          'd' => '(lookup) a.x dot d is a hash entry',
+          'd.x' => '(lookup) a.x dot d.x is a hash entry',
+          'd.z' => {
+            'g' => '(lookup) a.x dot d.z dot g is a hash entry'
+          }
+        },
+        'x.1' => '(lookup) x dot 1',
+        'key' => 'subkey'
+      }
+    }
+
+    let(:scope) {
+      {
+        'a.b' => '(scope) a dot b',
+        'a' => {
+          'd' => '(scope) a dot d is a hash entry',
+          'd.x' => '(scope) a dot d.x is a hash entry',
+          'd.z' => {
+            'g' => '(scope) a dot d.z dot g is a hash entry'}
+        },
+        'a.x' => {
+          'd' => '(scope) a.x dot d is a hash entry',
+          'd.x' => '(scope) a.x dot d.x is a hash entry',
+          'd.z' => {
+            'g' => '(scope) a.x dot d.z dot g is a hash entry'
+          }
+        },
+        'x.1' => '(scope) x dot 1',
+      }
+    }
+
+    it 'should find an entry using a quoted interpolation' do
+      expect(interpolator.interpolate("a dot c: %{'a.b'}", lookup_invocation, true)).to eq('a dot c: (scope) a dot b')
+    end
+
+    it 'should find an entry using a quoted interpolation with method lookup' do
+      expect_lookup('a.b')
+      expect(interpolator.interpolate("a dot c: %{lookup(\"'a.b'\")}", lookup_invocation, true)).to eq('a dot c: (lookup) a dot b')
+    end
+
+    it 'should find an entry using a quoted interpolation with method alias' do
+      expect_lookup('a.b')
+      expect(interpolator.interpolate("%{alias(\"'a.b'\")}", lookup_invocation, true)).to eq('(lookup) a dot b')
+    end
+
+    it 'should use a dotted key to navigate into a structure when it is not quoted' do
+      expect(interpolator.interpolate('a dot e: %{a.d}', lookup_invocation, true)).to eq('a dot e: (scope) a dot d is a hash entry')
+    end
+
+    it 'should use a dotted key to navigate into a structure when when it is not quoted with method lookup' do
+      expect_lookup('a')
+      expect(interpolator.interpolate("a dot e: %{lookup('a.d')}", lookup_invocation, true)).to eq('a dot e: (lookup) a dot d is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is last' do
+      expect(interpolator.interpolate("a dot ex: %{a.'d.x'}", lookup_invocation, true)).to eq('a dot ex: (scope) a dot d.x is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is last and method is lookup' do
+      expect_lookup('a')
+      expect(interpolator.interpolate("a dot ex: %{lookup(\"a.'d.x'\")}", lookup_invocation, true)).to eq('a dot ex: (lookup) a dot d.x is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is first' do
+      expect(interpolator.interpolate("a dot xe: %{'a.x'.d}", lookup_invocation, true)).to eq('a dot xe: (scope) a.x dot d is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is first and method is lookup' do
+      expect_lookup('a.x')
+      expect(interpolator.interpolate("a dot xe: %{lookup(\"'a.x'.d\")}", lookup_invocation, true)).to eq('a dot xe: (lookup) a.x dot d is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is in the middle' do
+      expect(interpolator.interpolate("a dot xm: %{a.'d.z'.g}", lookup_invocation, true)).to eq('a dot xm: (scope) a dot d.z dot g is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is in the middle and method is lookup' do
+      expect_lookup('a')
+      expect(interpolator.interpolate("a dot xm: %{lookup(\"a.'d.z'.g\")}", lookup_invocation, true)).to eq('a dot xm: (lookup) a dot d.z dot g is a hash entry')
+    end
+
+    it 'should use a mix of several quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is in the middle' do
+      expect(interpolator.interpolate("a dot xx: %{'a.x'.'d.z'.g}", lookup_invocation, true)).to eq('a dot xx: (scope) a.x dot d.z dot g is a hash entry')
+    end
+
+    it 'should use a mix of several quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is in the middle and method is lookup' do
+      expect_lookup('a.x')
+      expect(interpolator.interpolate("a dot xx: %{lookup(\"'a.x'.'d.z'.g\")}", lookup_invocation, true)).to eq('a dot xx: (lookup) a.x dot d.z dot g is a hash entry')
+    end
+
+    it 'should find an entry using using a quoted interpolation on dotted key containing numbers' do
+      expect(interpolator.interpolate("x dot 2: %{'x.1'}", lookup_invocation, true)).to eq('x dot 2: (scope) x dot 1')
+    end
+
+    it 'should find an entry using using a quoted interpolation on dotted key containing numbers using method lookup' do
+      expect_lookup('x.1')
+      expect(interpolator.interpolate("x dot 2: %{lookup(\"'x.1'\")}", lookup_invocation, true)).to eq('x dot 2: (lookup) x dot 1')
+    end
+
+    it 'should not find a subkey when the dotted key is quoted' do
+      expect(interpolator.interpolate("a dot f: %{'a.d'}", lookup_invocation, true)).to eq('a dot f: ')
+    end
+
+    it 'should not find a subkey when the dotted key is quoted with method lookup' do
+      expect_lookup('a.d')
+      expect(interpolator.interpolate("a dot f: %{lookup(\"'a.d'\")}", lookup_invocation, true)).to eq('a dot f: ')
+    end
+
+    it 'should not find a subkey that is matched within a string' do
+      expect_lookup('key')
+      expect{ interpolator.interpolate('%{hiera("key.subkey")}', lookup_invocation, true) }.to raise_error(/Got String when a hash-like object was expected to access value using 'subkey' from key 'key.subkey'/)
+    end
+  end
+
+  context 'when dealing with non alphanumeric characters' do
+    let(:data) {
+      {
+        'a key with whitespace' => 'value for a ws key',
+        'ws_key' => '%{alias("a key with whitespace")}',
+        '\#@!&%|' => 'not happy',
+        'angry' => '%{alias("\#@!&%|")}',
+        '!$\%!' => {
+          '\#@!&%|' => 'not happy at all'
+        },
+        'very_angry' => '%{alias("!$\%!.\#@!&%|")}',
+        'a key with' => {
+          'nested whitespace' => 'value for nested ws key',
+          ' untrimmed whitespace ' => 'value for untrimmed ws key'
+        }
+      }
+    }
+
+    it 'allows keys with white space' do
+      expect_lookup('ws_key', 'a key with whitespace')
+      expect(interpolator.interpolate("%{lookup('ws_key')}", lookup_invocation, true)).to eq('value for a ws key')
+    end
+
+    it 'allows keys with non alphanumeric characters' do
+      expect_lookup('angry', '\#@!&%|')
+      expect(interpolator.interpolate("%{lookup('angry')}", lookup_invocation, true)).to eq('not happy')
+    end
+
+    it 'allows dotted keys with non alphanumeric characters' do
+      expect_lookup('very_angry', '!$\%!')
+      expect(interpolator.interpolate("%{lookup('very_angry')}", lookup_invocation, true)).to eq('not happy at all')
+    end
+
+    it 'allows dotted keys with nested white space' do
+      expect_lookup('a key with')
+      expect(interpolator.interpolate("%{lookup('a key with.nested whitespace')}", lookup_invocation, true)).to eq('value for nested ws key')
+    end
+
+    it 'will trim each key element' do
+      expect_lookup('a key with')
+      expect(interpolator.interpolate("%{lookup(' a key with . nested whitespace ')}", lookup_invocation, true)).to eq('value for nested ws key')
+    end
+
+    it 'will not trim quoted key element' do
+      expect_lookup('a key with')
+      expect(interpolator.interpolate("%{lookup(' a key with .\" untrimmed whitespace \"')}", lookup_invocation, true)).to eq('value for untrimmed ws key')
+    end
+
+    it 'will not trim spaces outside of quoted key element' do
+      expect_lookup('a key with')
+      expect(interpolator.interpolate("%{lookup(' a key with .  \" untrimmed whitespace \"  ')}", lookup_invocation, true)).to eq('value for untrimmed ws key')
+    end
+  end
+
+  context 'when dealing with bad keys' do
+    it 'should produce an error when different quotes are used on either side' do
+      expect { interpolator.interpolate("%{'the.key\"}", lookup_invocation, true)}.to raise_error("Syntax error in string: %{'the.key\"}")
+    end
+
+    it 'should produce an if there is only one quote' do
+      expect { interpolator.interpolate("%{the.'key}", lookup_invocation, true)}.to raise_error("Syntax error in string: %{the.'key}")
+    end
+
+    it 'should produce an error for an empty segment' do
+      expect { interpolator.interpolate('%{the..key}', lookup_invocation, true)}.to raise_error("Syntax error in string: %{the..key}")
+    end
+
+    it 'should produce an error for an empty quoted segment' do
+      expect { interpolator.interpolate("%{the.''.key}", lookup_invocation, true)}.to raise_error("Syntax error in string: %{the.''.key}")
+    end
+
+    it 'should produce an error for an partly quoted segment' do
+      expect { interpolator.interpolate("%{the.'pa'key}", lookup_invocation, true)}.to raise_error("Syntax error in string: %{the.'pa'key}")
+    end
+
+    it 'should produce an error when different quotes are used on either side in a method argument' do
+      expect { interpolator.interpolate("%{lookup('the.key\")}", lookup_invocation, true)}.to raise_error("Syntax error in string: %{lookup('the.key\")}")
+    end
+
+    it 'should produce an error unless a known interpolation method is used' do
+      expect { interpolator.interpolate("%{flubber(\"hello\")}", lookup_invocation, true)}.to raise_error("Unknown interpolation method 'flubber'")
+    end
+  end
+end
+end

data/spec/unit/pops/migration_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/evaluator/evaluator_impl'
+require 'puppet/loaders'
+require 'puppet_spec/pops'
+require 'puppet_spec/scope'
+require 'puppet/parser/e4_parser_adapter'
+
+describe 'Puppet::Pops::MigrationMigrationChecker' do
+  include PuppetSpec::Pops
+  include PuppetSpec::Scope
+  before(:each) do
+    Puppet[:strict_variables] = true
+
+    # Puppetx cannot be loaded until the correct parser has been set (injector is turned off otherwise)
+    require 'puppet_x'
+
+    # Tests needs a known configuration of node/scope/compiler since it parses and evaluates
+    # snippets as the compiler will evaluate them, butwithout the overhead of compiling a complete
+    # catalog for each tested expression.
+    #
+    @parser  = Puppet::Pops::Parser::EvaluatingParser.new
+    @node = Puppet::Node.new('node.example.com')
+    @node.environment = Puppet::Node::Environment.create(:testing, [])
+    @compiler = Puppet::Parser::Compiler.new(@node)
+    @scope = Puppet::Parser::Scope.new(@compiler)
+    @scope.source = Puppet::Resource::Type.new(:node, 'node.example.com')
+    @scope.parent = @compiler.topscope
+  end
+
+  let(:scope) { @scope }
+
+  describe "when there is no MigrationChecker in the PuppetContext" do
+    it "a null implementation of the MigrationChecker gets created (once per impl that needs one)" do
+      migration_checker = Puppet::Pops::Migration::MigrationChecker.new()
+      Puppet::Pops::Migration::MigrationChecker.expects(:new).at_least_once.returns(migration_checker)
+      expect(Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "1", __FILE__)).to eq(1)
+      Puppet::Pops::Migration::MigrationChecker.unstub(:new)
+    end
+  end
+
+  describe "when there is a MigrationChecker in the Puppet Context" do
+    it "does not create any MigrationChecker instances when parsing and evaluating" do
+      migration_checker = mock()
+      Puppet::Pops::Migration::MigrationChecker.expects(:new).never
+      Puppet.override({:migration_checker => migration_checker}, "test-context") do
+        Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "true", __FILE__)
+      end
+      Puppet::Pops::Migration::MigrationChecker.unstub(:new)
+    end
+  end
+end