puppet 4.4.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/parser/lexer2_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 require 'matchers/match_tokens2'
 require 'puppet/pops'
 require 'puppet/pops/parser/lexer2'
-require_relative './parser_rspec_helper'
 
 module EgrammarLexer2Spec
   def tokens_scanned_from(s)
@@ -20,7 +19,6 @@ end
 
 describe 'Lexer2' do
   include EgrammarLexer2Spec
-  include ParserRspecHelper
 
   {
     :LISTSTART => '[',
@@ -116,13 +114,8 @@ describe 'Lexer2' do
   end
 
   context 'when app_managment is (turned) on' do
-    before(:each) do
-      with_app_management(true)
-    end
-
-    after(:each) do
-      with_app_management(false)
-    end
+    before(:each) { Puppet[:app_management] = true }
+    after(:each) { Puppet[:app_management] = false }
 
     {
       "application"  => :APPLICATION,

data/spec/unit/pops/parser/parse_application_spec.rb

@@ -1,18 +1,13 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
-require_relative './parser_rspec_helper'
+require_relative 'parser_rspec_helper'
 
 describe "egrammar parsing of 'application'" do
   include ParserRspecHelper
 
-  before(:each) do
-    with_app_management(true)
-  end
-
-  after(:each) do
-    with_app_management(false)
-  end
+  before(:each) { Puppet[:app_management] = true }
+  after(:each) { Puppet[:app_management] = false }
 
   it "an empty body" do
     expect(dump(parse("application foo { }"))).to eq("(application foo () ())")

data/spec/unit/pops/parser/parse_basic_expressions_spec.rb

@@ -168,6 +168,25 @@ describe "egrammar parsing basic expressions" do
       expect(parse("[]").current.body.length).to eq(2)
       expect(parse("[ ]").current.body.length).to eq(3)
     end
+
+    {
+      'keyword' => %w(type function),
+      'reserved word' => %w(application site produces consumes)
+    }.each_pair do |word_type, words|
+      words.each do |word|
+        it "allows the #{word_type} '#{word}' in a list" do
+          expect(dump(parse("$a = [#{word}]"))).to(eq("(= $a ([] '#{word}'))"))
+        end
+
+        it "allows the #{word_type} '#{word}' as a key in a hash" do
+          expect(dump(parse("$a = {#{word}=>'x'}"))).to(eq("(= $a ({} ('#{word}' 'x')))"))
+        end
+
+        it "allows the #{word_type} '#{word}' as a value in a hash" do
+          expect(dump(parse("$a = {'x'=>#{word}}"))).to(eq("(= $a ({} ('x' '#{word}')))"))
+        end
+      end
+    end
   end
 
   context "When parsing indexed access" do

data/spec/unit/pops/parser/parse_capabilities_spec.rb

@@ -1,20 +1,13 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
-
-# relative to this spec file (./) does not work as this file is loaded by rspec
-require File.join(File.dirname(__FILE__), '/parser_rspec_helper')
+require_relative 'parser_rspec_helper'
 
 describe "egrammar parsing of capability mappings" do
   include ParserRspecHelper
 
-  before(:each) do
-    with_app_management(true)
-  end
-
-  after(:each) do
-    with_app_management(false)
-  end
+  before(:each) { Puppet[:app_management] = true }
+  after(:each) { Puppet[:app_management] = false }
 
   context "when parsing 'produces'" do
     it "the ast contains produces and attributes" do

data/spec/unit/pops/parser/parse_site_spec.rb

@@ -1,20 +1,13 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
-
-# relative to this spec file (./) does not work as this file is loaded by rspec
-require File.join(File.dirname(__FILE__), '/parser_rspec_helper')
+require_relative 'parser_rspec_helper'
 
 describe "egrammar parsing of site expression" do
   include ParserRspecHelper
 
-  before(:each) do
-    with_app_management(true)
-  end
-
-  after(:each) do
-    with_app_management(false)
-  end
+  before(:each) { Puppet[:app_management] = true }
+  after(:each) { Puppet[:app_management] = false }
 
   context "when parsing 'site'" do
     it "an empty body is allowed" do
@@ -35,4 +28,20 @@ describe "egrammar parsing of site expression" do
       expect(dump(parse(prog))).to eq(ast)
     end
   end
+
+  context 'When parsing collections containing application management specific keywords' do
+    %w(application site produces consumes).each do |keyword|
+      it "allows the keyword '#{keyword}' in a list" do
+        expect(dump(parse("$a = [#{keyword}]"))).to(eq("(= $a ([] '#{keyword}'))"))
+      end
+
+      it "allows the keyword '#{keyword}' as a key in a hash" do
+        expect(dump(parse("$a = {#{keyword}=>'x'}"))).to(eq("(= $a ({} ('#{keyword}' 'x')))"))
+      end
+
+      it "allows the keyword '#{keyword}' as a value in a hash" do
+        expect(dump(parse("$a = {'x'=>#{keyword}}"))).to(eq("(= $a ({} ('x' '#{keyword}')))"))
+      end
+    end
+  end
 end

data/spec/unit/pops/parser/parser_rspec_helper.rb

@@ -5,10 +5,6 @@ require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
 module ParserRspecHelper
   include FactoryRspecHelper
 
-  def with_app_management(flag)
-    Puppet[:app_management] = flag
-  end
-
   def parse(code)
     parser = Puppet::Pops::Parser::Parser.new()
     parser.parse_string(code)

data/spec/unit/pops/types/enumeration_spec.rb

@@ -1,50 +1,51 @@
 require 'spec_helper'
 require 'puppet/pops'
 
+module Puppet::Pops::Types
 describe 'The enumeration support' do
   it 'produces an enumerator for Array' do
-  expect(Puppet::Pops::Types::Enumeration.enumerator([1,2,3]).respond_to?(:next)).to eql(true)
+  expect(Enumeration.enumerator([1,2,3]).respond_to?(:next)).to eql(true)
   end
 
   it 'produces an enumerator for Hash' do
-    expect(Puppet::Pops::Types::Enumeration.enumerator({:a=>1}).respond_to?(:next)).to eql(true)
+    expect(Enumeration.enumerator({:a=>1}).respond_to?(:next)).to eql(true)
   end
 
   it 'produces a char enumerator for String' do
-    enum = Puppet::Pops::Types::Enumeration.enumerator("abc")
+    enum = Enumeration.enumerator("abc")
     expect(enum.respond_to?(:next)).to eql(true)
     expect(enum.next).to eql('a')
   end
 
   it 'produces an enumerator for integer times' do
-    enum = Puppet::Pops::Types::Enumeration.enumerator(2)
+    enum = Enumeration.enumerator(2)
     expect(enum.next).to eql(0)
     expect(enum.next).to eql(1)
     expect{enum.next}.to raise_error(StopIteration)
   end
 
   it 'produces an enumerator for Integer range' do
-    range = Puppet::Pops::Types::TypeFactory.range(1,2)
-    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    range = TypeFactory.range(1,2)
+    enum = Enumeration.enumerator(range)
     expect(enum.next).to eql(1)
     expect(enum.next).to eql(2)
     expect{enum.next}.to raise_error(StopIteration)
   end
 
   it 'does not produce an enumerator for infinite Integer range' do
-    range = Puppet::Pops::Types::TypeFactory.range(1,:default)
-    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    range = TypeFactory.range(1,:default)
+    enum = Enumeration.enumerator(range)
     expect(enum).to be_nil
-    range = Puppet::Pops::Types::TypeFactory.range(:default,2)
-    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    range = TypeFactory.range(:default,2)
+    enum = Enumeration.enumerator(range)
     expect(enum).to be_nil
   end
 
   [3.14, /.*/, true, false, nil, :something].each do |x|
     it "does not produce an enumerator for object of type #{x.class}" do
-      enum = Puppet::Pops::Types::Enumeration.enumerator(x)
+      enum = Enumeration.enumerator(x)
       expect(enum).to be_nil
     end
   end
-
+end
 end

data/spec/unit/pops/types/iterable_spec.rb

@@ -256,7 +256,7 @@ describe 'The iterable support' do
   end
 
   it 'will produce the string Iterator[T] on to_s on an iterator instance with element type T' do
-    expect(Iterable.on(18).to_s).to eq('Iterator[Integer] value')
+    expect(Iterable.on(18).to_s).to eq('Iterator[Integer]-Value')
   end
 end
-end
+end