puppet 4.2.0 → 4.3.0

data/spec/unit/network/authconfig_spec.rb

@@ -3,80 +3,80 @@ require 'spec_helper'
 
 require 'puppet/network/authconfig'
 
-describe Puppet::Network::AuthConfig do
+describe Puppet::Network::DefaultAuthProvider do
   before :each do
     Puppet::FileSystem.stubs(:stat).returns stub('stat', :ctime => :now)
     Time.stubs(:now).returns Time.now
 
-    Puppet::Network::AuthConfig.any_instance.stubs(:exists?).returns(true)
-    # FIXME @authconfig = Puppet::Network::AuthConfig.new("dummy")
+    Puppet::Network::DefaultAuthProvider.any_instance.stubs(:exists?).returns(true)
+    # FIXME @authprovider = Puppet::Network::DefaultAuthProvider.new("dummy")
   end
 
   describe "when initializing" do
     it "inserts default ACLs after setting initial rights" do
-      Puppet::Network::AuthConfig.any_instance.expects(:insert_default_acl)
-      Puppet::Network::AuthConfig.new
+      Puppet::Network::DefaultAuthProvider.any_instance.expects(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.new
     end
   end
 
   describe "when defining an acl with mk_acl" do
     before :each do
-      Puppet::Network::AuthConfig.any_instance.stubs(:insert_default_acl)
-      @authconfig = Puppet::Network::AuthConfig.new
+      Puppet::Network::DefaultAuthProvider.any_instance.stubs(:insert_default_acl)
+      @authprovider = Puppet::Network::DefaultAuthProvider.new
     end
 
     it "should create a new right for each default acl" do
-      @authconfig.mk_acl(:acl => '/')
-      expect(@authconfig.rights['/']).to be
+      @authprovider.mk_acl(:acl => '/')
+      expect(@authprovider.rights['/']).to be
     end
 
     it "allows everyone for each default right" do
-      @authconfig.mk_acl(:acl => '/')
-      expect(@authconfig.rights['/']).to be_globalallow
+      @authprovider.mk_acl(:acl => '/')
+      expect(@authprovider.rights['/']).to be_globalallow
     end
 
     it "accepts an argument to restrict the method" do
-      @authconfig.mk_acl(:acl => '/', :method => :find)
-      expect(@authconfig.rights['/'].methods).to eq([:find])
+      @authprovider.mk_acl(:acl => '/', :method => :find)
+      expect(@authprovider.rights['/'].methods).to eq([:find])
     end
 
     it "creates rights with authentication set to true by default" do
-      @authconfig.mk_acl(:acl => '/')
-      expect(@authconfig.rights['/'].authentication).to be_truthy
+      @authprovider.mk_acl(:acl => '/')
+      expect(@authprovider.rights['/'].authentication).to be_truthy
     end
 
     it "accepts an argument to set the authentication requirement" do
-      @authconfig.mk_acl(:acl => '/', :authenticated => :any)
-      expect(@authconfig.rights['/'].authentication).to be_falsey
+      @authprovider.mk_acl(:acl => '/', :authenticated => :any)
+      expect(@authprovider.rights['/'].authentication).to be_falsey
     end
   end
 
   describe "when adding default ACLs" do
     before :each do
-      Puppet::Network::AuthConfig.any_instance.stubs(:insert_default_acl)
-      @authconfig = Puppet::Network::AuthConfig.new
-      Puppet::Network::AuthConfig.any_instance.unstub(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.any_instance.stubs(:insert_default_acl)
+      @authprovider = Puppet::Network::DefaultAuthProvider.new
+      Puppet::Network::DefaultAuthProvider.any_instance.unstub(:insert_default_acl)
     end
 
-    Puppet::Network::AuthConfig::default_acl.each do |acl|
+    Puppet::Network::DefaultAuthProvider::default_acl.each do |acl|
       it "should create a default right for #{acl[:acl]}" do
-        @authconfig.stubs(:mk_acl)
-        @authconfig.expects(:mk_acl).with(acl)
-        @authconfig.insert_default_acl
+        @authprovider.stubs(:mk_acl)
+        @authprovider.expects(:mk_acl).with(acl)
+        @authprovider.insert_default_acl
       end
     end
 
     it "should log at info loglevel" do
       Puppet.expects(:info).at_least_once
-      @authconfig.insert_default_acl
+      @authprovider.insert_default_acl
     end
 
     it "creates an empty catch-all rule for '/' for any authentication request state" do
-      @authconfig.stubs(:mk_acl)
+      @authprovider.stubs(:mk_acl)
 
-      @authconfig.insert_default_acl
-      expect(@authconfig.rights['/']).to be_empty
-      expect(@authconfig.rights['/'].authentication).to be_falsey
+      @authprovider.insert_default_acl
+      expect(@authprovider.rights['/']).to be_empty
+      expect(@authprovider.rights['/'].authentication).to be_falsey
     end
 
     it '(CVE-2013-2275) allows report submission only for the node matching the certname by default' do
@@ -86,9 +86,9 @@ describe Puppet::Network::AuthConfig do
         :allow => '$1',
         :authenticated => true
       }
-      @authconfig.stubs(:mk_acl)
-      @authconfig.expects(:mk_acl).with(acl)
-      @authconfig.insert_default_acl
+      @authprovider.stubs(:mk_acl)
+      @authprovider.expects(:mk_acl).with(acl)
+      @authprovider.insert_default_acl
     end
   end
 
@@ -107,3 +107,33 @@ describe Puppet::Network::AuthConfig do
     end
   end
 end
+
+describe Puppet::Network::AuthConfig do
+  after :each do
+    Puppet::Network::AuthConfig.authprovider_class = nil
+  end
+
+  class TestAuthProvider
+    def initialize(rights=nil); end
+    def check_authorization(method, path, params); end
+  end
+
+  it "instantiates authprovider_class with rights" do
+    Puppet::Network::AuthConfig.authprovider_class = TestAuthProvider
+    rights = Puppet::Network::Rights.new
+    TestAuthProvider.expects(:new).with(rights)
+    described_class.new(rights)
+  end
+
+  it "delegates authorization check to authprovider_class" do
+    Puppet::Network::AuthConfig.authprovider_class = TestAuthProvider
+    TestAuthProvider.any_instance.expects(:check_authorization).with(:save, '/path/to/resource', {})
+    described_class.new.check_authorization(:save, '/path/to/resource', {})
+  end
+
+  it "uses DefaultAuthProvider by default" do
+    Puppet::Network::AuthConfig.authprovider_class = nil
+    Puppet::Network::DefaultAuthProvider.any_instance.expects(:check_authorization).with(:save, '/path/to/resource', {})
+    described_class.new.check_authorization(:save, '/path/to/resource', {})
+  end
+end

data/spec/unit/network/authorization_spec.rb

@@ -1,5 +1,7 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/network/http'
+require 'puppet/network/http/api/indirected_routes'
 require 'puppet/network/authorization'
 
 describe Puppet::Network::Authorization do
@@ -9,7 +11,7 @@ describe Puppet::Network::Authorization do
 
   subject { AuthTest.new }
 
-  describe "when creating an authconfig object" do
+  context "when creating an authconfig object" do
     before :each do
       # Other tests may have created an authconfig, so we have to undo that.
       @orig_auth_config = Puppet::Network::AuthConfigLoader.instance_variable_get(:@auth_config)
@@ -26,9 +28,35 @@ describe Puppet::Network::Authorization do
 
     it "creates default ACL entries if no file has been read" do
       Puppet::Network::AuthConfigParser.expects(:new_from_file).raises Errno::ENOENT
-      Puppet::Network::AuthConfig.any_instance.expects(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.any_instance.expects(:insert_default_acl)
 
       subject.authconfig
     end
   end
+
+  class TestAuthConfig
+    def check_authorization(method, path, params); end
+  end
+
+  class TestAuthConfigLoader
+    def self.authconfig
+      TestAuthConfig.new
+    end
+  end
+
+  context "when checking authorization" do
+    after :each do
+      Puppet::Network::Authorization.authconfigloader_class = nil
+    end
+
+    it "delegates to the authconfig object" do
+      Puppet::Network::Authorization.authconfigloader_class =
+          TestAuthConfigLoader
+      TestAuthConfig.any_instance.expects(:check_authorization).with(
+          :save, '/mypath', {:param1 => "value1"}).returns("yay, it worked!")
+      expect(subject.check_authorization(
+                 :save, '/mypath',
+                 {:param1 => "value1"})).to eq("yay, it worked!")
+    end
+  end
 end

data/spec/unit/network/authstore_spec.rb

@@ -180,7 +180,7 @@ describe Puppet::Network::AuthStore::Declaration do
   ].each { |invalid_ip|
     describe "when the pattern is an invalid IPv6 address such as #{invalid_ip}" do
       it "should raise an exception" do
-        expect { Puppet::Network::AuthStore::Declaration.new(:allow,invalid_ip) }.to raise_error
+        expect { Puppet::Network::AuthStore::Declaration.new(:allow,invalid_ip) }.to raise_error(Puppet::AuthStoreError, /Invalid pattern/)
       end
     end
   }

data/spec/unit/network/http/compression_spec.rb

@@ -173,7 +173,7 @@ describe "http compression" do
       it "should raise the error the second time" do
         @inflater.stubs(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
         Zlib::Inflate.expects(:new).with.returns(@inflater)
-        expect { @adapter.uncompress("chunk") }.to raise_error
+        expect { @adapter.uncompress("chunk") }.to raise_error(Zlib::DataError, /not a zlib stream/)
       end
 
       it "should finish the stream on close" do

data/spec/unit/network/http/connection_spec.rb

@@ -42,31 +42,18 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
-  context "when methods that accept a block are called with a block" do
-    let (:host) { "my_server" }
+  context "when handling requests", :vcr do
+    let (:host) { "my-server" }
     let (:port) { 8140 }
     let (:subject) { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator) }
 
-    before :each do
-      httpok.stubs(:body).returns ""
-
-      # This stubbing relies a bit more on knowledge of the internals of Net::HTTP
-      # than I would prefer, but it works on ruby 1.8.7 and 1.9.3, and it seems
-      # valuable enough to have tests for blocks that this is probably warranted.
-      socket = stub_everything("socket")
-      TCPSocket.stubs(:open).returns(socket)
-
-      Net::HTTP::Post.any_instance.stubs(:exec).returns("")
-      Net::HTTP::Head.any_instance.stubs(:exec).returns("")
-      Net::HTTP::Get.any_instance.stubs(:exec).returns("")
-      Net::HTTPResponse.stubs(:read_new).returns(httpok)
-    end
-
-    [:request_get, :request_head, :request_post].each do |method|
+    { :request_get  => {},
+      :request_head => {},
+      :request_post => "param: value" }.each do |method,body|
       context "##{method}" do
         it "should yield to the block" do
           block_executed = false
-          subject.send(method, "/foo", {}) do |response|
+          subject.send(method, "/foo", body) do |response|
             block_executed = true
           end
           expect(block_executed).to eq(true)
@@ -118,6 +105,14 @@ describe Puppet::Network::HTTP::Connection do
     let (:host) { "my_server" }
     let (:port) { 8140 }
 
+    before :all do
+      WebMock.disable!
+    end
+
+    after :all do
+      WebMock.enable!
+    end
+
     it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet.features.microsoft_windows? do
       connection = Puppet::Network::HTTP::Connection.new(
         host, port,

data/spec/unit/network/http/handler_spec.rb

@@ -131,11 +131,6 @@ describe Puppet::Network::HTTP::Handler do
       handler.process(request, response)
     end
 
-    it "should raise an error if the request is formatted in an unknown format" do
-      handler.stubs(:content_type_header).returns "unknown format"
-      expect { handler.request_format(request) }.to raise_error
-    end
-
     it "should still find the correct format if content type contains charset information" do
       request = Puppet::Network::HTTP::Request.new({ 'content-type' => "text/plain; charset=UTF-8" },
                                                    {}, 'GET', '/', nil)

data/spec/unit/network/rights_spec.rb

@@ -29,7 +29,7 @@ describe Puppet::Network::Rights do
   end
 
   it "should throw an error if type can't be determined" do
-    expect { @right.newright("name") }.to raise_error
+    expect { @right.newright("name") }.to raise_error(ArgumentError, /Unknown right type/)
   end
 
   describe "when creating new path ACLs" do
@@ -40,7 +40,7 @@ describe Puppet::Network::Rights do
     end
 
     it "should throw an error if the acl uri path is not absolute" do
-      expect { @right.newright("name")}.to raise_error
+      expect { @right.newright("name")}.to raise_error(ArgumentError, /Unknown right type/)
     end
 
     it "should create a new ACL with the correct path" do
@@ -351,7 +351,7 @@ describe Puppet::Network::Rights do
     it "should raise an error if the method is already filtered" do
       @acl.restrict_method(:save)
 
-      expect { @acl.restrict_method(:save) }.to raise_error
+      expect { @acl.restrict_method(:save) }.to raise_error(ArgumentError, /'save' is already in the '\/path'/)
     end
 
     it "should allow setting an environment filters" do

data/spec/unit/node_spec.rb

@@ -88,6 +88,33 @@ describe Puppet::Node do
     end
   end
 
+  describe "when serializing using yaml" do
+    before do
+      @node = Puppet::Node.new("mynode")
+    end
+
+    it "a node can roundtrip" do
+      expect(YAML.load(@node.to_yaml).name).to eql("mynode")
+    end
+
+    it "limits the serialization of environment to be just the name" do
+      # it is something like 138 when serializing everything in a default environment
+      expect(@node.to_yaml.size).to be < 70
+    end
+  end
+
+  describe "when serializing using yaml and values classes and parameters are missing in deserialized hash" do
+    it "a node can roundtrip" do
+      @node = Puppet::Node.from_data_hash({'name' => "mynode"})
+      expect(YAML.load(@node.to_yaml).name).to eql("mynode")
+    end
+
+    it "errors if name is nil" do
+      expect { Puppet::Node.from_data_hash({ })}.to raise_error(ArgumentError, /No name provided in serialized data/)
+    end
+
+  end
+
   describe "when converting to json" do
     before do
       @node = Puppet::Node.new("mynode")

data/spec/unit/parser/ast/leaf_spec.rb

@@ -93,7 +93,7 @@ describe Puppet::Parser::AST::HostName do
   end
 
   it "should raise an error if hostname is not valid" do
-    expect { Puppet::Parser::AST::HostName.new( :value => "not a hostname!" ) }.to raise_error
+    expect { Puppet::Parser::AST::HostName.new( :value => "not a hostname!" ) }.to raise_error(Puppet::DevError, /'not a hostname!' is not a valid hostname/)
   end
 
   it "should not raise an error if hostname is a regex" do

data/spec/unit/parser/compiler_spec.rb

@@ -49,6 +49,10 @@ class CompilerTestResource
   def line
     "42"
   end
+
+  def resource_type
+    self.class
+  end
 end
 
 describe Puppet::Parser::Compiler do
@@ -112,6 +116,7 @@ describe Puppet::Parser::Compiler do
     it "should set its node attribute" do
       expect(@compiler.node).to equal(@node)
     end
+
     it "should detect when ast nodes are absent" do
       expect(@compiler.ast_nodes?).to be_falsey
     end
@@ -141,11 +146,90 @@ describe Puppet::Parser::Compiler do
       expect(compiler.classlist).to match_array(['foo', 'bar'])
     end
 
+    it "should return a catalog with the specified code_id" do
+      node = Puppet::Node.new("mynode")
+      code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      compiler = Puppet::Parser::Compiler.new(node, :code_id => code_id)
+
+      expect(compiler.catalog.code_id).to eq(code_id)
+    end
+
     it "should add a 'main' stage to the catalog" do
       expect(@compiler.catalog.resource(:stage, :main)).to be_instance_of(Puppet::Parser::Resource)
     end
   end
 
+  describe "sanitize_node" do
+    it "should delete trusted from parameters" do
+      node = Puppet::Node.new("mynode")
+      node.parameters['trusted'] =  { :a => 42 }
+      node.parameters['preserve_me'] = 'other stuff'
+      compiler = Puppet::Parser::Compiler.new(node)
+      sanitized = compiler.node
+      expect(sanitized.parameters['trusted']).to eq(nil)
+      expect(sanitized.parameters['preserve_me']).to eq('other stuff')
+    end
+
+    it "should not report trusted_data if trusted is false" do
+      node = Puppet::Node.new("mynode")
+      node.parameters['trusted'] = false
+      compiler = Puppet::Parser::Compiler.new(node)
+      sanitized = compiler.node
+      expect(sanitized.trusted_data).to_not eq(false)
+    end
+
+    it "should not report trusted_data if trusted is not a hash" do
+      node = Puppet::Node.new("mynode")
+      node.parameters['trusted'] = 'not a hash'
+      compiler = Puppet::Parser::Compiler.new(node)
+      sanitized = compiler.node
+      expect(sanitized.trusted_data).to_not eq('not a hash')
+    end
+
+    it "should not report trusted_data if trusted hash doesn't include known keys" do
+      node = Puppet::Node.new("mynode")
+      node.parameters['trusted'] = { :a => 42 }
+      compiler = Puppet::Parser::Compiler.new(node)
+      sanitized = compiler.node
+      expect(sanitized.trusted_data).to_not eq({ :a => 42 })
+    end
+
+    it "should report 'trusted' parameters as trusted_data but as inauthentic if running as non-root" do
+      node = Puppet::Node.new("mynode")
+      node.parameters['trusted'] = { 'authenticated' => true,
+                                     'certname'      => 'foo',
+                                     'extensions'    => 'things' }
+
+      Puppet.features.stubs(:root?).returns(false)
+
+      Puppet.ignore(:trusted_information)
+      compiler = Puppet::Parser::Compiler.new(node)
+      Puppet.restore(:trusted_information)
+
+      sanitized = compiler.node
+      expect(sanitized.trusted_data).to eq({ 'authenticated' => false,
+                                             'certname'      => 'foo',
+                                             'extensions'    => 'things' })
+    end
+
+    it "should prefer trusted_data in the node above other plausible sources" do
+      node = Puppet::Node.new("mynode")
+      node.trusted_data = { 'authenticated' => true,
+                           'certname'      => 'the real deal',
+                           'extensions'    => 'things' }
+
+      node.parameters['trusted'] = { 'authenticated' => true,
+                                     'certname'      => 'not me',
+                                     'extensions'    => 'things' }
+
+      compiler = Puppet::Parser::Compiler.new(node)
+      sanitized = compiler.node
+      expect(sanitized.trusted_data).to eq({ 'authenticated' => true,
+                                             'certname'      => 'the real deal',
+                                             'extensions'    => 'things' })
+    end
+  end
+
   describe "when managing scopes" do
 
     it "should create a top scope" do
@@ -629,7 +713,7 @@ describe Puppet::Parser::Compiler do
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {'a' => nil, 'b' => nil})
       @compiler.topscope.known_resource_types.add klass
-      expect { @compiler.compile }.to raise_error(Puppet::ParseError, "Must pass b to Class[Foo]")
+      expect { @compiler.compile }.to raise_error(Puppet::PreformattedError, /Class\[Foo\]: expects a value for parameter 'b'/)
     end
 
     it "should fail if invalid parameters are passed" do
@@ -637,7 +721,7 @@ describe Puppet::Parser::Compiler do
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {})
       @compiler.topscope.known_resource_types.add klass
-      expect { @compiler.compile }.to raise_error(Puppet::ParseError, "Invalid parameter: '3' on Class[Foo]")
+      expect { @compiler.compile }.to raise_error(Puppet::PreformattedError, /Class\[Foo\]: has no parameter named '3'/)
     end
 
     it "should ensure class is in catalog without params" do

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -103,7 +103,7 @@ describe 'function for dynamically creating resources' do
 
           create_resources('foocreateresource', {'blah'=>{}})
         MANIFEST
-      }.to raise_error(Puppet::Error, 'Must pass one to Foocreateresource[blah] on node foonode')
+      }.to raise_error(Puppet::Error, /Foocreateresource\[blah\]: expects a value for parameter 'one' on node foonode/)
     end
 
     it 'should be able to add multiple defines' do

data/spec/unit/parser/resource_spec.rb

@@ -105,9 +105,9 @@ describe Puppet::Parser::Resource do
       @arguments = {:scope => @scope}
     end
 
-    it "should fail unless #{name.to_s} is specified" do
+    it "should fail unless hash is specified" do
       expect {
-        Puppet::Parser::Resource.new('file', '/my/file')
+        Puppet::Parser::Resource.new('file', '/my/file', nil)
       }.to raise_error(ArgumentError, /Resources require a hash as last argument/)
     end
 
@@ -531,24 +531,6 @@ describe Puppet::Parser::Resource do
     end
   end
 
-  describe "when validating" do
-    it "should check each parameter" do
-      resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => stub("source")
-      resource[:one] = :two
-      resource[:three] = :four
-      resource.expects(:validate_parameter).with(:one)
-      resource.expects(:validate_parameter).with(:three)
-      resource.send(:validate)
-    end
-
-    it "should raise a parse error when there's a failure" do
-      resource = Puppet::Parser::Resource.new :foo, "bar", :scope => @scope, :source => stub("source")
-      resource[:one] = :two
-      resource.expects(:validate_parameter).with(:one).raises ArgumentError
-      expect { resource.send(:validate) }.to raise_error(Puppet::ParseError)
-    end
-  end
-
   describe "when setting parameters" do
     before do
       @source = newclass "foobar"

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

@@ -16,7 +16,7 @@ describe 'BinderConfig' do
     expect(config.layering_config[0]['name']).to    be == 'site'
     expect(config.layering_config[0]['include']).to be == ['confdir:/default?optional']
     expect(config.layering_config[1]['name']).to    be == 'modules'
-    expect(config.layering_config[1]['include']).to be == ['module:/*::default']
+    expect(config.layering_config[1]['include']).to be == ['module:/*::default', 'module:/*::metadata']
   end
 
   it 'should load binder_config.yaml if it exists in confdir)' do

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

@@ -594,11 +594,11 @@ describe 'Injector' do
       it "should fail attempts to append, perform  uniq or flatten on type incompatible multibind hash" do
         hash_of_integer = type_factory.hash_of(type_factory.integer())
         ids = ["ducks1", "ducks2", "ducks3"]
-        mb = bindings.multibind(ids[0]).type(hash_of_integer.copy).name('broken_family0')
+        mb = bindings.multibind(ids[0]).type(hash_of_integer).name('broken_family0')
         mb.producer_options(:conflict_resolution => :append)
-        mb = bindings.multibind(ids[1]).type(hash_of_integer.copy).name('broken_family1')
+        mb = bindings.multibind(ids[1]).type(hash_of_integer).name('broken_family1')
         mb.producer_options(:flatten => :true)
-        mb = bindings.multibind(ids[2]).type(hash_of_integer.copy).name('broken_family2')
+        mb = bindings.multibind(ids[2]).type(hash_of_integer).name('broken_family2')
         mb.producer_options(:uniq => :true)
 
         injector = injector(binder.new(factory.layered_bindings(test_layer_with_bindings(bindings.model))))

data/spec/unit/pops/evaluator/access_ops_spec.rb

@@ -208,13 +208,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces a size constrained Array when the last two arguments specify this' do
       expr = fqr('Array')[fqr('String'), 1]
-      expected_t = types.array_of(String)
-      types.constrain_size(expected_t, 1, :default)
+      expected_t = types.array_of(String, types.range(1, :default))
       expect(evaluate(expr)).to be_the_type(expected_t)
 
       expr = fqr('Array')[fqr('String'), 1, 2]
-      expected_t = types.array_of(String)
-      types.constrain_size(expected_t, 1, 2)
+      expected_t = types.array_of(String, types.range(1, 2))
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
 
@@ -227,11 +225,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     #
     it 'produces a Tuple[String] from the expression Tuple[String]' do
       expr = fqr('Tuple')[fqr('String')]
-      expect(evaluate(expr)).to be_the_type(types.tuple(String))
+      expect(evaluate(expr)).to be_the_type(types.tuple([String]))
 
       # arguments are flattened
       expr = fqr('Tuple')[[fqr('String')]]
-      expect(evaluate(expr)).to be_the_type(types.tuple(String))
+      expect(evaluate(expr)).to be_the_type(types.tuple([String]))
     end
 
     it "Tuple parameterization gives an error if parameter is not a type" do
@@ -241,13 +239,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces a varargs Tuple when the last two arguments specify size constraint' do
       expr = fqr('Tuple')[fqr('String'), 1]
-      expected_t = types.tuple(String)
-      types.constrain_size(expected_t, 1, :default)
+      expected_t = types.tuple([String], types.range(1, :default))
       expect(evaluate(expr)).to be_the_type(expected_t)
 
       expr = fqr('Tuple')[fqr('String'), 1, 2]
-      expected_t = types.tuple(String)
-      types.constrain_size(expected_t, 1, 2)
+      expected_t = types.tuple([String], types.range(1, 2))
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
 
@@ -416,7 +412,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
     it 'produces a NotUndef instance with String type when given a literal String' do
       type_expr = fqr('NotUndef')[literal('hey')]
       tf = Puppet::Pops::Types::TypeFactory
-      expect(evaluate(type_expr)).to eql(tf.not_undef(tf.string('hey')))
+      expect(evaluate(type_expr)).to be_the_type(tf.not_undef(tf.string(nil, 'hey')))
+    end
+
+    it 'Produces Optional instance with String type when using a String argument' do
+      type_expr = fqr('Optional')[literal('hey')]
+      tf = Puppet::Pops::Types::TypeFactory
+      expect(evaluate(type_expr)).to be_the_type(tf.optional(tf.string(nil, 'hey')))
     end
 
     # Type Type

data/spec/unit/pops/evaluator/basic_expressions_spec.rb

@@ -31,8 +31,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'should evaluator types to types' do
-      array_type = Puppet::Pops::Types::PArrayType.new()
-      array_type.element_type = Puppet::Pops::Types::PDataType.new()
+      array_type = Puppet::Pops::Types::PArrayType::DATA
       expect(evaluate(fqr('Array'))).to eq(array_type)
     end
   end