puppet 4.5.3-x64-mingw32 → 4.6.1-x64-mingw32

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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops
+module Serialization
+describe 'RGen' do
+  let!(:env) { Puppet::Node::Environment.create(:testing, []) }
+  let!(:loaders) { Puppet::Pops::Loaders.new(env) }
+  let!(:loader) { loaders.find_loader(nil) }
+
+  around :each do |example|
+    Puppet.override(:loaders => loaders, :current_environment => env) do
+      example.run
+    end
+  end
+
+  def find_parent(type, parent_name)
+    p = type
+    while p.is_a?(Types::PObjectType) && p.name != parent_name
+      p = p.parent
+    end
+    expect(p).to be_a(Types::PObjectType), "did not find #{parent_name} in parent chain of #{type.name}"
+    p
+  end
+
+  context 'TypeGenerator' do
+
+    let!(:generator) { RGen::TypeGenerator.new }
+    let!(:type_set) { generator.generate_type_set('PuppetSpec::Bindings', Binder::Bindings, loader) }
+    let!(:bindings_classes) do
+      Binder::Bindings.constants.each_with_object([]) do |n, a|
+        cls = Binder::Bindings.const_get(n)
+        a << cls if cls.is_a?(Class) && cls.respond_to?(:ecore)
+      end
+    end
+
+    it 'generates TypeSet from a module that represents an ECore package' do
+      expect(type_set).to be_a(Types::PTypeSetType)
+      expect(type_set.types).not_to be_empty
+      expect(type_set.types.size).to eql(bindings_classes.size)
+    end
+
+    it 'all types are in the PuppetSpec::Bindings namespace' do
+      type_set.types.values.each {|type| expect(type.name).to start_with('PuppetSpec::Bindings::') }
+    end
+
+    it 'all types extend from PuppetSpec::Bindings::BindingsModelObject' do
+      type_set.types.values.each do |type|
+        expect(find_parent(type, 'PuppetSpec::Bindings::BindingsModelObject').name).to eq('PuppetSpec::Bindings::BindingsModelObject')
+      end
+    end
+  end
+
+  context 'AST model types' do
+    let!(:impl_repo) { Loaders.implementation_registry }
+    let!(:loader) {  Loaders.find_loader(nil) }
+    let!(:type_set) { Types::TypeParser.singleton.parse('Puppet::AST', loader) }
+    let!(:ast_classes) do
+      Model.constants.each_with_object([]) do |n, a|
+        cls = Model.const_get(n)
+        a << cls if cls.is_a?(Class) && cls.respond_to?(:ecore)
+      end
+    end
+
+    it 'can be mapped from the ecore classes found in Puppet::Pops::Model' do
+      ast_classes.each { |ast_class| expect(impl_repo.type_for_module(ast_class)).to be_a(Types::PObjectType) }
+    end
+
+    it 'are contained in a TypeSet named Puppet::AST' do
+      expect(type_set).to be_a(Types::PTypeSetType)
+      expect(type_set.name).to eq('Puppet::AST')
+      expect(type_set.types.size).to eql(ast_classes.size + 1)  # +1 because the Locator is added
+    end
+
+    it 'all reside in the Puppet::AST namespace' do
+      type_set.types.values.each {|type| expect(type.name).to start_with('Puppet::AST::') }
+    end
+
+    it 'all extend from Puppet::AST::PopsObject' do
+      type_set.types.values.each do |type|
+        next if type.name == 'Puppet::AST::Locator'
+        expect(find_parent(type, 'Puppet::AST::PopsObject').name).to eq('Puppet::AST::PopsObject')
+      end
+    end
+  end
+end
+end
+end

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

@@ -0,0 +1,228 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops
+module Serialization
+[JSON].each do |packer_module|
+  describe "the Puppet::Pops::Serialization over #{packer_module.name}" do
+  let!(:dumper) { Model::ModelTreeDumper.new }
+  let(:io) { StringIO.new }
+  let(:parser) { Parser::EvaluatingParser.new }
+  let(:env) { Puppet::Node::Environment.create(:testing, []) }
+  let(:loaders) { Puppet::Pops::Loaders.new(env) }
+  let(:loader) { loaders.find_loader(nil) }
+  let(:reader_class) { packer_module::Reader }
+  let(:writer_class) { packer_module::Writer }
+
+  around :each do |example|
+     Puppet.override(:loaders => loaders, :current_environment => env) do
+      example.run
+    end
+  end
+
+  def write(*values)
+    io.reopen
+    serializer = Serializer.new(writer_class.new(io))
+    values.each { |val| serializer.write(val) }
+    serializer.finish
+    io.rewind
+  end
+
+  def read
+    deserializer = Deserializer.new(reader_class.new(io), loaders.find_loader(nil))
+    deserializer.read
+  end
+
+  def parse(string)
+    parser.parse_string(string, '/home/tester/experiments/manifests/init.pp').current
+  end
+
+  context 'can write and read a Scalar' do
+    it 'String' do
+      val = 'the value'
+      write(val)
+      val2 = read
+      expect(val2).to be_a(String)
+      expect(val2).to eql(val)
+    end
+
+    it 'Integer' do
+      val = 32
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Integer)
+      expect(val2).to eql(val)
+    end
+
+    it 'Float' do
+      val = 32.45
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Float)
+      expect(val2).to eql(val)
+    end
+
+    it 'true' do
+      val = true
+      write(val)
+      val2 = read
+      expect(val2).to be_a(TrueClass)
+      expect(val2).to eql(val)
+    end
+
+    it 'false' do
+      val = false
+      write(val)
+      val2 = read
+      expect(val2).to be_a(FalseClass)
+      expect(val2).to eql(val)
+    end
+
+    it 'nil' do
+      val = nil
+      write(val)
+      val2 = read
+      expect(val2).to be_a(NilClass)
+      expect(val2).to eql(val)
+    end
+
+    it 'Regexp' do
+      val = /match me/
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Regexp)
+      expect(val2).to eql(val)
+    end
+
+    it 'Time created by TimeFactory' do
+      # It does succeed on rare occasions, so we need to repeat
+      val = TimeFactory.now
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Time)
+      expect(val2).to eql(val)
+    end
+
+    it 'Version' do
+      # It does succeed on rare occasions, so we need to repeat
+      val = Semantic::Version.parse('1.2.3-alpha2')
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Semantic::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')
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Semantic::VersionRange)
+      expect(val2).to eql(val)
+    end
+  end
+
+  context 'can write and read' do
+    include_context 'types_setup'
+
+    it 'all default types' do
+      all_types.each do |t|
+        val = t::DEFAULT
+        write(val)
+        val2 = read
+        expect(val2).to be_a(t)
+        expect(val2).to eql(val)
+      end
+    end
+
+    context 'a parameterized' do
+      it 'String' do
+        val = Types::TypeFactory.string(Types::TypeFactory.range(1, :default))
+        write(val)
+        val2 = read
+        expect(val2).to be_a(Types::PStringType)
+        expect(val2).to eql(val)
+      end
+
+      it 'Regex' do
+        val = Types::TypeFactory.regexp(/foo/)
+        write(val)
+        val2 = read
+        expect(val2).to be_a(Types::PRegexpType)
+        expect(val2).to eql(val)
+      end
+
+      it 'Variant' do
+        val = Types::TypeFactory.variant(Types::TypeFactory.string, Types::TypeFactory.range(1, :default))
+        write(val)
+        val2 = read
+        expect(val2).to be_a(Types::PVariantType)
+        expect(val2).to eql(val)
+      end
+
+      it 'Object' do
+        val = Types::TypeParser.singleton.parse('Pcore::StringType', loader)
+        write(val)
+        val2 = read
+        expect(val2).to be_a(Types::PObjectType)
+        expect(val2).to eql(val)
+      end
+    end
+
+    context 'an AST model' do
+      it "Locator" do
+        val = Parser::Locator::Locator19.new('here is some text', '/tmp/foo', [5])
+        write(val)
+        val2 = read
+        expect(val2).to be_a(Parser::Locator::Locator19)
+        expect(val2).to eql(val)
+      end
+
+      it 'nested Expression' do
+        expr = parse(<<-CODE)
+          $rootgroup = $osfamily ? {
+              'Solaris'          => 'wheel',
+              /(Darwin|FreeBSD)/ => 'wheel',
+              default            => 'root',
+          }
+
+          file { '/etc/passwd':
+            ensure => file,
+            owner  => 'root',
+            group  => $rootgroup,
+          }
+        CODE
+        write(expr)
+        expr2 = read
+        expect(dumper.dump(expr)).to eq(dumper.dump(expr2))
+      end
+    end
+  end
+
+  context 'When debugging' do
+    let(:debug_io) { StringIO.new }
+    let(:writer) { reader_class.new(io, { :debug_io => debug_io, :tabulate => false, :verbose => true }) }
+
+    it 'can write and read an AST expression' do
+      expr = parse(<<-CODE)
+        $rootgroup = $osfamily ? {
+            'Solaris'          => 'wheel',
+            /(Darwin|FreeBSD)/ => 'wheel',
+            default            => 'root',
+        }
+
+        file { '/etc/passwd':
+          ensure => file,
+          owner  => 'root',
+          group  => $rootgroup,
+        }
+      CODE
+      write(expr)
+      expr2 = read
+      expect(dumper.dump(expr)).to eq(dumper.dump(expr2))
+    end
+  end
+end
+end
+end
+end

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

@@ -7,14 +7,14 @@ module Types
 describe 'The Object Type' do
   include PuppetSpec::Compiler
 
-  let(:parser) { TypeParser.new }
+  let(:parser) { TypeParser.singleton }
   let(:pp_parser) { Parser::EvaluatingParser.new }
   let(:loader) { Loader::BaseLoader.new(nil, 'type_parser_unit_test_loader') }
   let(:factory) { TypeFactory }
 
   def type_object_t(name, body_string)
     object = PObjectType.new(name, pp_parser.parse_string("{#{body_string}}").current.body)
-    loader.set_entry(Loader::Loader::TypedName.new(:type, name.downcase), object)
+    loader.set_entry(Loader::TypedName.new(:type, name.downcase), object)
     object
   end
 
@@ -1055,6 +1055,48 @@ describe 'The Object Type' do
       end
     end
   end
+
+  context 'is assigned to all PAnyType classes such that' do
+    include_context 'types_setup'
+
+    def find_parent(tc, parent_name)
+      p = tc._ptype
+      while p.is_a?(PObjectType) && p.name != parent_name
+        p = p.parent
+      end
+      expect(p).to be_a(PObjectType), "did not find #{parent_name} in parent chain of #{tc.name}"
+      p
+    end
+
+    it 'the class has a _ptype method' do
+      all_types.each do |tc|
+        expect(tc).to respond_to(:_ptype).with(0).arguments
+      end
+    end
+
+    it 'the _ptype method returns a PObjectType instance' do
+      all_types.each do |tc|
+        expect(tc._ptype).to be_a(PObjectType)
+      end
+    end
+
+    it 'the instance returned by _ptype is a descendant from Pcore::AnyType' do
+      all_types.each { |tc| expect(find_parent(tc, 'Pcore::AnyType').name).to eq('Pcore::AnyType') }
+    end
+
+    it 'PScalarType classes _ptype returns a descendant from Pcore::ScalarType' do
+      scalar_types.each { |tc| expect(find_parent(tc, 'Pcore::ScalarType').name).to eq('Pcore::ScalarType') }
+    end
+
+    it 'PNumericType classes _ptype returns a descendant from Pcore::NumberType' do
+      numeric_types.each { |tc| expect(find_parent(tc, 'Pcore::NumericType').name).to eq('Pcore::NumericType') }
+    end
+
+    it 'PCollectionType classes _ptype returns a descendant from Pcore::CollectionType' do
+      coll_descendants = collection_types - [PTupleType, PStructType]
+      coll_descendants.each { |tc| expect(find_parent(tc, 'Pcore::CollectionType').name).to eq('Pcore::CollectionType') }
+    end
+  end
 end
 end
 end

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

@@ -13,6 +13,48 @@ describe 'Semantic Versions' do
       expect(t).to be_a(PSemVerType)
       expect(t).to eql(TypeFactory.sem_ver('>=1.0.0 <4.0.0'))
     end
+
+    context 'convert method' do
+      it 'returns nil on a nil argument' do
+        expect(PSemVerType.convert(nil)).to be_nil
+      end
+
+      it 'returns its argument when the argument is a version' do
+        v = Semantic::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)
+        expect(PSemVerType.convert('1.0.0')).to eq(v)
+      end
+
+      it 'raises an error string that does not represent a valid version' do
+        expect{PSemVerType.convert('1-3')}.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'the SemVerRange type' do
+     context 'convert method' do
+      it 'returns nil on a nil argument' do
+        expect(PSemVerRangeType.convert(nil)).to be_nil
+      end
+
+      it 'returns its argument when the argument is a version range' do
+        vr = Semantic::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')
+        expect(PSemVerRangeType.convert('1.x')).to eq(vr)
+      end
+
+      it 'raises an error string that does not represent a valid version range' do
+        expect{PSemVerRangeType.convert('x3')}.to raise_error(ArgumentError)
+      end
+    end
   end
 
   context 'when used in Puppet expressions' do

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

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Types
+describe 'Sensitive Type' do
+  include PuppetSpec::Compiler
+
+  context 'as a type' do
+    it 'can be created without a parameter with the type factory' do
+      t = TypeFactory.sensitive
+      expect(t).to be_a(PSensitiveType)
+      expect(t).to eql(PSensitiveType::DEFAULT)
+    end
+
+    it 'can be created with a parameter with the type factory' do
+      t = TypeFactory.sensitive(PIntegerType::DEFAULT)
+      expect(t).to be_a(PSensitiveType)
+      expect(t.type).to eql(PIntegerType::DEFAULT)
+    end
+
+    context 'when used in Puppet expressions' do
+      it 'is equal to itself only' do
+        code = <<-CODE
+          $t = Sensitive
+          notice(Sensitive =~ Type[ Sensitive ])
+          notice(Sensitive == Sensitive)
+          notice(Sensitive < Sensitive)
+          notice(Sensitive > Sensitive)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['true', 'true', 'false', 'false'])
+      end
+
+      context "when parameterized" do
+        it 'is equal other types with the same parameterization' do
+          code = <<-CODE
+            notice(Sensitive[String] == Sensitive[String])
+            notice(Sensitive[Numeric] != Sensitive[Integer])
+          CODE
+          expect(eval_and_collect_notices(code)).to eq(['true', 'true'])
+        end
+
+        it 'orders parameterized types based on the type system hierarchy' do
+          code = <<-CODE
+            notice(Sensitive[Numeric] > Sensitive[Integer])
+            notice(Sensitive[Numeric] < Sensitive[Integer])
+          CODE
+          expect(eval_and_collect_notices(code)).to eq(['true', 'false'])
+        end
+
+        it 'does not order incomparable parameterized types' do
+          code = <<-CODE
+            notice(Sensitive[String] < Sensitive[Integer])
+            notice(Sensitive[String] > Sensitive[Integer])
+          CODE
+          expect(eval_and_collect_notices(code)).to eq(['false', 'false'])
+        end
+
+        it 'generalizes passed types to prevent information leakage' do
+          code =<<-CODE
+            $it = String[7, 7]
+            $st = Sensitive[$it]
+            notice(type($st))
+          CODE
+          expect(eval_and_collect_notices(code)).to eq(['Type[Sensitive[String]]'])
+        end
+      end
+    end
+  end
+
+  context 'a Sensitive instance' do
+    it 'can be created from a string and does not leak its contents' do
+      code =<<-CODE
+        $o = Sensitive("hunter2")
+        notice($o)
+        notice(type($o))
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['Sensitive [value redacted]', 'Sensitive[String]'])
+    end
+
+    it 'matches the appropriate parameterized type' do
+      code =<<-CODE
+        $o = Sensitive("hunter2")
+        notice(assert_type(Sensitive[String], $o))
+        notice(assert_type(Sensitive[String[7, 7]], $o))
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['Sensitive [value redacted]', 'Sensitive [value redacted]'])
+    end
+
+    it 'verifies the constrains of the parameterized type' do
+      pending "the ability to enforce constraints without leaking information"
+      code =<<-CODE
+        $o = Sensitive("hunter2")
+        notice(assert_type(Sensitive[String[10, 20]], $o))
+      CODE
+      expect {
+        eval_and_collect_notices(code)
+      }.to raise_error(Puppet::Error, /expected a Sensitive\[String\[10, 20\]\] value, got Sensitive\[String\[7, 7\]\]/)
+    end
+
+    it 'does not match an inappropriate parameterized type' do
+      code =<<-CODE
+        $o = Sensitive("hunter2")
+        notice(assert_type(Sensitive[Integer], $o) |$expected, $actual| {
+          "$expected != $actual"
+        })
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['Sensitive[Integer] != Sensitive[String]'])
+    end
+
+    it 'can be created from another sensitive instance ' do
+      code =<<-CODE
+        $o = Sensitive("hunter2")
+        $x = Sensitive($o)
+        notice(assert_type(Sensitive[String], $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eq(['Sensitive [value redacted]'])
+    end
+  end
+
+  it "enforces wrapped type constraints" do
+    pending "the ability to enforce constraints without leaking information"
+    code =<<-CODE
+        class secrets_handler(Sensitive[Array[String[4, 8]]] $pwlist) {
+            notice($pwlist)
+        }
+
+        class { "secrets_handler":
+            pwlist => Sensitive(['hi', 'longlonglong'])
+        }
+    CODE
+    expect {
+      expect(eval_and_collect_notices(code))
+    }.to raise_error(Puppet::Error, /expects a String\[4, 8\], got String/)
+  end
+end
+end
+end