puppet 4.8.2-universal-darwin → 4.9.0-universal-darwin

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

@@ -1,18 +1,23 @@
 #! /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
+  include Lookup::SubLookup
 
   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]) }
+    keys.each do |key|
+      segments = split_key(key)
+      root_key = segments.shift
+      found = data[root_key]
+      found = sub_lookup(key, lookup_invocation, segments, found) unless segments.empty?
+      Lookup.expects(:lookup).with(key, nil, '', true, nil, lookup_invocation).returns(found)
+    end
   end
 
   context 'when interpolating nested data' do
@@ -160,12 +165,12 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'should find an entry using a quoted interpolation with method lookup' do
-      expect_lookup('a.b')
+      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_lookup("'a.b'")
       expect(interpolator.interpolate("%{alias(\"'a.b'\")}", lookup_invocation, true)).to eq('(lookup) a dot b')
     end
 
@@ -173,8 +178,12 @@ describe 'Puppet::Pops::Lookup::Interpolation' 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')
+    it 'should report a key missing and replace with empty string when a dotted key is used to navigate into a structure and then not found' do
+      expect(interpolator.interpolate('a dot n: %{a.n}', lookup_invocation, true)).to eq('a dot n: ')
+    end
+
+    it 'should use a dotted key to navigate into a structure when it is not quoted with method lookup' do
+      expect_lookup('a.d')
       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
 
@@ -183,7 +192,7 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     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_lookup("a.'d.x'")
       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
 
@@ -192,7 +201,7 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     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_lookup("'a.x'.d")
       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
 
@@ -201,7 +210,7 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     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_lookup("a.'d.z'.g")
       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
 
@@ -210,7 +219,7 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     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_lookup("'a.x'.'d.z'.g")
       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
 
@@ -219,7 +228,7 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     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_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
 
@@ -228,13 +237,12 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'should not find a subkey when the dotted key is quoted with method lookup' do
-      expect_lookup('a.d')
+      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'/)
+      expect{ expect_lookup('key.subkey') }.to raise_error(/Got String when a hash-like object was expected to access value using 'subkey' from key 'key.subkey'/)
     end
   end
 
@@ -267,27 +275,27 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'allows dotted keys with non alphanumeric characters' do
-      expect_lookup('very_angry', '!$\%!')
+      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_lookup('a key with.nested whitespace')
       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_lookup(' a key with . nested whitespace ')
       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_lookup(' a key with ." untrimmed whitespace "')
       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_lookup(' a key with .  " untrimmed whitespace "  ')
       expect(interpolator.interpolate("%{lookup(' a key with .  \" untrimmed whitespace \"  ')}", lookup_invocation, true)).to eq('value for untrimmed ws key')
     end
   end

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

@@ -0,0 +1,197 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet/pops'
+require 'deep_merge/core'
+
+module Puppet::Pops
+module Lookup
+describe 'The lookup API' do
+  include PuppetSpec::Files
+
+  let(:env_name) { 'spec' }
+  let(:code_dir) { Puppet[:environmentpath] }
+  let(:env_dir) { File.join(code_dir, env_name) }
+  let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, 'modules')]) }
+  let(:node) { Puppet::Node.new('test', :environment => env) }
+  let(:compiler) { Puppet::Parser::Compiler.new(node) }
+  let(:scope) { compiler.topscope }
+  let(:invocation) { Invocation.new(scope) }
+
+  let(:code_dir_content) do
+    {
+      'hiera.yaml' => <<-YAML.unindent,
+        version: 5
+        YAML
+      'data' => {
+        'common.yaml' => <<-YAML.unindent
+          a: a (from global)
+          d: d (from global)
+          mod::e: mod::e (from global)
+          YAML
+      }
+    }
+  end
+
+  let(:env_content) do
+    {
+      'hiera.yaml' => <<-YAML.unindent,
+        version: 5
+        YAML
+      'data' => {
+        'common.yaml' => <<-YAML.unindent
+          b: b (from environment)
+          d: d (from environment)
+          mod::f: mod::f (from environment)
+          YAML
+      }
+    }
+  end
+
+  let(:mod_content) do
+    {
+      'hiera.yaml' => <<-YAML.unindent,
+        version: 5
+        YAML
+      'data' => {
+        'common.yaml' => <<-YAML.unindent
+          mod::c: mod::c (from module)
+          mod::e: mod::e (from module)
+          mod::f: mod::f (from module)
+          YAML
+      }
+    }
+  end
+
+  let(:populated_env_dir) do
+    all_content = code_dir_content.merge(env_name => env_content.merge('modules' => { 'mod' => mod_content }))
+    dir_contained_in(code_dir, all_content)
+    all_content.keys.each { |key| PuppetSpec::Files.record_tmp(File.join(code_dir, key)) }
+    env_dir
+  end
+
+  before(:each) do
+    Puppet[:hiera_config] = File.join(code_dir, 'hiera.yaml')
+    Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))
+  end
+
+  after(:each) do
+    Puppet.pop_context
+  end
+
+  context 'when doing lookup' do
+    it 'finds data in global layer' do
+      expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
+    end
+
+    it 'finds data in environment layer' do
+      expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('b (from environment)')
+    end
+
+    it 'global layer wins over environment layer' do
+      expect(Lookup.lookup('d', nil, 'not found', true, nil, invocation)).to eql('d (from global)')
+    end
+
+    it 'finds data in module layer' do
+      expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('mod::c (from module)')
+    end
+
+    it 'global layer wins over module layer' do
+      expect(Lookup.lookup('mod::e', nil, 'not found', true, nil, invocation)).to eql('mod::e (from global)')
+    end
+
+    it 'environment layer wins over module layer' do
+      expect(Lookup.lookup('mod::f', nil, 'not found', true, nil, invocation)).to eql('mod::f (from environment)')
+    end
+
+    context "with 'global_only' set to true in the invocation" do
+      let(:invocation) { Invocation.new(scope).set_global_only }
+
+      it 'finds data in global layer' do
+        expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
+      end
+
+      it 'does not find data in environment layer' do
+        expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('not found')
+      end
+
+      it 'does not find data in module layer' do
+        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('not found')
+      end
+    end
+
+    context "with 'global_only' set to true in the lookup adapter" do
+      it 'finds data in global layer' do
+        invocation.lookup_adapter.set_global_only
+        expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
+      end
+
+      it 'does not find data in environment layer' do
+        invocation.lookup_adapter.set_global_only
+        expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('not found')
+      end
+
+      it 'does not find data in module layer' do
+        invocation.lookup_adapter.set_global_only
+        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('not found')
+      end
+    end
+
+    context 'with subclassed lookup adpater' do
+      let(:other_dir) { tmpdir('other') }
+      let(:other_dir_content) do
+        {
+          'hiera.yaml' => <<-YAML.unindent,
+            version: 5
+            YAML
+          'data' => {
+            'common.yaml' => <<-YAML.unindent
+              a: a (from other global)
+              d: d (from other global)
+              mod::e: mod::e (from other global)
+              YAML
+          }
+        }
+      end
+
+      let(:populated_other_dir) do
+        dir_contained_in(other_dir, other_dir_content)
+        other_dir
+      end
+
+      before(:each) do
+        eval(<<-RUBY.unindent)
+        class SpecialLookupAdapter < LookupAdapter
+           def initialize(compiler)
+             super
+             set_global_only
+             set_global_hiera_config_path(File.join('#{populated_other_dir}', 'hiera.yaml'))
+           end
+        end
+        RUBY
+      end
+
+      after(:each) do
+        Puppet::Pops::Lookup.send(:remove_const, :SpecialLookupAdapter)
+      end
+
+      let(:other_invocation) { Invocation.new(scope, EMPTY_HASH, EMPTY_HASH, nil, SpecialLookupAdapter) }
+
+      it 'finds different data in global layer' do
+        expect(Lookup.lookup('a', nil, nil, false, nil, other_invocation)).to eql('a (from other global)')
+        expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
+      end
+
+      it 'does not find data in environment layer' do
+        expect(Lookup.lookup('b', nil, 'not found', true, nil, other_invocation)).to eql('not found')
+        expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('b (from environment)')
+      end
+
+      it 'does not find data in module layer' do
+        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, other_invocation)).to eql('not found')
+        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('mod::c (from module)')
+      end
+    end
+  end
+end
+end
+end

data/spec/unit/pops/merge_strategy_spec.rb

@@ -0,0 +1,18 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops
+describe 'MergeStrategy' do
+  context 'deep merge' do
+    it 'does not mutate the source of a merge' do
+      a = { 'a' => { 'b' => 'va' }, 'c' => 2 }
+      b = { 'a' => { 'b' => 'vb' }, 'b' => 3}
+      c = MergeStrategy.strategy(:deep).merge(a, b);
+      expect(a).to eql({ 'a' => { 'b' => 'va' }, 'c' => 2 })
+      expect(b).to eql({ 'a' => { 'b' => 'vb' }, 'b' => 3 })
+      expect(c).to eql({ 'a' => { 'b' => 'va' }, 'b' => 3, 'c' => 2 })
+    end
+  end
+end
+end

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

@@ -513,7 +513,15 @@ describe 'Lexer2' do
       "x\\u2713y"
       CODE
       # >= Ruby 1.9.3 reports \u
-       expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u2713y"])
+      expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u2713y"])
+    end
+
+    it 'should support adjacent short form unicode characters' do
+      code = <<-CODE
+      "x\\u2713\\u2713y"
+      CODE
+      # >= Ruby 1.9.3 reports \u
+      expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u2713\u2713y"])
     end
 
     it 'should support unicode characters in long form' do
@@ -523,6 +531,13 @@ describe 'Lexer2' do
       expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u{1f452}y"])
     end
 
+    it 'can escape the unicode escape' do
+      code = <<-"CODE"
+      "x\\\\u{1f452}y"
+      CODE
+      expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\\u{1f452}y"])
+    end
+
     it 'produces byte offsets that counts each byte in a comment' do
       code = <<-"CODE"
       # \u{0400}\na

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

@@ -42,6 +42,10 @@ describe "egrammar parsing of site expression" do
       it "allows the keyword '#{keyword}' as a value in a hash" do
         expect(dump(parse("$a = {'x'=>#{keyword}}"))).to(eq("(= $a ({} ('x' '#{keyword}')))"))
       end
+
+      it "allows the keyword '#{keyword}' as an attribute name" do
+        expect(dump(parse("foo { 'x': #{keyword} => 'value' } "))).to eql("(resource foo\n  ('x'\n    (#{keyword} => 'value')))")
+      end
     end
   end
 end

data/spec/unit/pops/serialization/packer_spec.rb

@@ -87,15 +87,6 @@ describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
       expect(val2).to eql(val)
     end
 
-    it 'Sensitive' do
-      sval = 'the sensitive value'
-      val = Types::PSensitiveType::Sensitive.new(sval)
-      write(val)
-      val2 = read
-      expect(val2).to be_a(Types::PSensitiveType::Sensitive)
-      expect(val2.unwrap).to eql(sval)
-    end
-
     it 'Timespan' do
       val = Time::Timespan.from_fields(false, 3, 12, 40, 31, 123)
       write(val)
@@ -113,18 +104,18 @@ describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
     end
 
     it 'Version' do
-      val = Semantic::Version.parse('1.2.3-alpha2')
+      val = SemanticPuppet::Version.parse('1.2.3-alpha2')
       write(val)
       val2 = read
-      expect(val2).to be_a(Semantic::Version)
+      expect(val2).to be_a(SemanticPuppet::Version)
       expect(val2).to eql(val)
     end
 
     it 'VersionRange' do
-      val = Semantic::VersionRange.parse('>=1.2.3-alpha2 <1.2.4')
+      val = SemanticPuppet::VersionRange.parse('>=1.2.3-alpha2 <1.2.4')
       write(val)
       val2 = read
-      expect(val2).to be_a(Semantic::VersionRange)
+      expect(val2).to be_a(SemanticPuppet::VersionRange)
       expect(val2).to eql(val)
     end
 
@@ -135,16 +126,6 @@ describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
       expect(val2).to be_a(Types::PBinaryType::Binary)
       expect(val2).to eql(val)
     end
-
-    it 'Sensitive with rich data' do
-      sval = Time::Timestamp.now
-      val = Types::PSensitiveType::Sensitive.new(sval)
-      write(val)
-      val2 = read
-      expect(val2).to be_a(Types::PSensitiveType::Sensitive)
-      expect(val2.unwrap).to be_a(Time::Timestamp)
-      expect(val2.unwrap).to eql(sval)
-    end
   end
 
   context 'will fail on attempts to write' do

data/spec/unit/pops/serialization/serialization_spec.rb

@@ -121,19 +121,19 @@ module Serialization
 
     it 'Version' do
       # It does succeed on rare occasions, so we need to repeat
-      val = Semantic::Version.parse('1.2.3-alpha2')
+      val = SemanticPuppet::Version.parse('1.2.3-alpha2')
       write(val)
       val2 = read
-      expect(val2).to be_a(Semantic::Version)
+      expect(val2).to be_a(SemanticPuppet::Version)
       expect(val2).to eql(val)
     end
 
     it 'VersionRange' do
       # It does succeed on rare occasions, so we need to repeat
-      val = Semantic::VersionRange.parse('>=1.2.3-alpha2 <1.2.4')
+      val = SemanticPuppet::VersionRange.parse('>=1.2.3-alpha2 <1.2.4')
       write(val)
       val2 = read
-      expect(val2).to be_a(Semantic::VersionRange)
+      expect(val2).to be_a(SemanticPuppet::VersionRange)
       expect(val2).to eql(val)
     end
 
@@ -186,6 +186,30 @@ module Serialization
         expect(val2).to eql(val)
       end
 
+      it 'Collection' do
+        val = Types::TypeFactory.collection(Types::TypeFactory.range(0, 20))
+        write(val)
+        val2 = read
+        expect(val2).to be_a(Types::PCollectionType)
+        expect(val2).to eql(val)
+      end
+
+      it 'Array' do
+        val = Types::TypeFactory.array_of(Types::TypeFactory.integer, Types::TypeFactory.range(0, 20))
+        write(val)
+        val2 = read
+        expect(val2).to be_a(Types::PArrayType)
+        expect(val2).to eql(val)
+      end
+
+      it 'Hash' do
+        val = Types::TypeFactory.hash_kv(Types::TypeFactory.string, Types::TypeFactory.integer, Types::TypeFactory.range(0, 20))
+        write(val)
+        val2 = read
+        expect(val2).to be_a(Types::PHashType)
+        expect(val2).to eql(val)
+      end
+
       it 'Variant' do
         val = Types::TypeFactory.variant(Types::TypeFactory.string, Types::TypeFactory.range(1, :default))
         write(val)
@@ -208,8 +232,8 @@ module Serialization
       val = [
         Time::Timespan.from_fields(false, 3, 12, 40, 31, 123),
         Time::Timestamp.now,
-        Semantic::Version.parse('1.2.3-alpha2'),
-        Semantic::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
+        SemanticPuppet::Version.parse('1.2.3-alpha2'),
+        SemanticPuppet::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
         Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
       ]
       write(val)
@@ -222,8 +246,8 @@ module Serialization
       val = {
         'duration' => Time::Timespan.from_fields(false, 3, 12, 40, 31, 123),
         'time' => Time::Timestamp.now,
-        'version' => Semantic::Version.parse('1.2.3-alpha2'),
-        'range' => Semantic::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
+        'version' => SemanticPuppet::Version.parse('1.2.3-alpha2'),
+        'range' => SemanticPuppet::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
         'binary' => Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
       }
       write(val)

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

@@ -9,9 +9,15 @@ describe 'The Object Type' do
 
   let(:parser) { TypeParser.singleton }
   let(:pp_parser) { Parser::EvaluatingParser.new }
-  let(:loader) { Loader::BaseLoader.new(nil, 'type_parser_unit_test_loader') }
+  let(:loader) { Loaders.find_loader(nil) }
   let(:factory) { TypeFactory }
 
+  around(:each) do |example|
+    Puppet.override(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
+      example.run
+    end
+  end
+
   def type_object_t(name, body_string)
     object = PObjectType.new(name, pp_parser.parse_string("{#{body_string}}").current.body)
     loader.set_entry(Loader::TypedName.new(:type, name.downcase), object)
@@ -148,7 +154,7 @@ describe 'The Object Type' do
   end
 
   context 'when dealing with functions' do
-    it 'raises an error when the function type is a Type[Callable]' do
+    it 'raises an error unless the function type is a Type[Callable]' do
       obj = <<-OBJECT
         functions => {
           a => String
@@ -207,7 +213,7 @@ describe 'The Object Type' do
         'function MyDerivedObject[a] attempts to override attribute MyObject[a]')
     end
 
-    it 'raises an error when the an function overrides an attribute' do
+    it 'raises an error when the a function overrides an attribute' do
       parent = <<-OBJECT
         functions => {
           a => Callable
@@ -699,6 +705,43 @@ describe 'The Object Type' do
     end
   end
 
+  context 'when stringifying created instances' do
+    it 'outputs a Puppet constructor using the initializer hash' do
+      code = <<-CODE
+      type Spec::MyObject = Object[{attributes => { a => Integer }}]
+      type Spec::MySecondObject = Object[{parent => Spec::MyObject, attributes => { b => String }}]
+      notice(Spec::MySecondObject(42, 'Meaning of life'))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(["Spec::MySecondObject({\n  'a' => 42,\n  'b' => 'Meaning of life'\n})"])
+    end
+  end
+
+  context 'when used from Ruby' do
+    it 'can create an instance without scope using positional arguments' do
+      parse_object('MyObject', <<-OBJECT)
+        attributes => {
+          a => { type => Integer }
+        }
+      OBJECT
+
+      t = Puppet::Pops::Types::TypeParser.singleton.parse('MyObject', Puppet::Pops::Loaders.find_loader(nil))
+      instance = t.create(32)
+      expect(instance.a).to eql(32)
+    end
+
+    it 'can create an instance without scope using initialization hash' do
+      parse_object('MyObject', <<-OBJECT)
+        attributes => {
+          a => { type => Integer }
+        }
+      OBJECT
+
+      t = Puppet::Pops::Types::TypeParser.singleton.parse('MyObject', Puppet::Pops::Loaders.find_loader(nil))
+      instance = t.from_hash('a' => 32)
+      expect(instance.a).to eql(32)
+    end
+  end
+
   context 'when used in Puppet expressions' do
     it 'two anonymous empty objects are equal' do
       code = <<-CODE
@@ -763,6 +806,28 @@ describe 'The Object Type' do
         /attribute MySecondObject\[a\] attempts to override final attribute MyObject\[a\]/)
     end
 
+    it 'can inherit from an aliased type' do
+      code = <<-CODE
+      type MyObject = Object[{ name => 'MyFirstObject', attributes => { a => Integer }}]
+      type MyObjectAlias = MyObject
+      type MySecondObject = Object[{ parent => MyObjectAlias, attributes => { b => String }}]
+      notice(MySecondObject < MyObjectAlias)
+      notice(MySecondObject < MyObject)
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true', 'true'])
+    end
+
+    it 'detects equality duplication when inherited from an aliased type' do
+      code = <<-CODE
+      type MyObject = Object[{ name => 'MyFirstObject', attributes => { a => Integer }}]
+      type MyObjectAlias = MyObject
+      type MySecondObject = Object[{ parent => MyObjectAlias, attributes => { b => String }, equality => a}]
+      notice(MySecondObject < MyObject)
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error,
+        /MySecondObject equality is referencing attribute MyObject\[a\] which is included in equality of MyObject/)
+    end
+
     it 'raises an error when object when circular inheritance is detected' do
       code = <<-CODE
       type MyFirstObject = Object[{

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

@@ -20,12 +20,12 @@ describe 'Semantic Versions' do
       end
 
       it 'returns its argument when the argument is a version' do
-        v = Semantic::Version.new(1,0,0)
+        v = SemanticPuppet::Version.new(1,0,0)
         expect(PSemVerType.convert(v)).to equal(v)
       end
 
       it 'converts a valid version string argument to a version' do
-        v = Semantic::Version.new(1,0,0)
+        v = SemanticPuppet::Version.new(1,0,0)
         expect(PSemVerType.convert('1.0.0')).to eq(v)
       end
 
@@ -42,12 +42,12 @@ describe 'Semantic Versions' do
       end
 
       it 'returns its argument when the argument is a version range' do
-        vr = Semantic::VersionRange.parse('1.x')
+        vr = SemanticPuppet::VersionRange.parse('1.x')
         expect(PSemVerRangeType.convert(vr)).to equal(vr)
       end
 
       it 'converts a valid version string argument to a version range' do
-        vr = Semantic::VersionRange.parse('1.x')
+        vr = SemanticPuppet::VersionRange.parse('1.x')
         expect(PSemVerRangeType.convert('1.x')).to eq(vr)
       end