puppet 5.3.7 → 5.4.0

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

@@ -0,0 +1,191 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Types
+describe 'URI type' do
+  context 'when used in Puppet expressions' do
+    include PuppetSpec::Compiler
+    it 'is equal to itself only' do
+      expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true true false false))
+          $t = URI
+          notice(URI =~ Type[URI])
+          notice(URI == URI)
+          notice(URI < URI)
+          notice(URI > URI)
+      CODE
+    end
+
+    context "when parameterized" do
+      it 'is equal other types with the same parameterization' do
+        code = <<-CODE
+            notice(URI == URI[{}])
+            notice(URI['http://example.com'] == URI[scheme => http, host => 'example.com'])
+            notice(URI['urn:a:b:c'] == URI[scheme => urn, opaque => 'a:b:c'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(%w(true true true))
+      end
+
+      it 'is assignable from more qualified types' do
+        expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true true true))
+          notice(URI > URI['http://example.com'])
+          notice(URI['http://example.com'] > URI['http://example.com/path'])
+          notice(URI[scheme => Enum[http, https]] > URI['http://example.com'])
+        CODE
+      end
+
+      it 'is not assignable unless scheme is assignable' do
+        expect(eval_and_collect_notices(<<-CODE)).to eq(%w(false))
+          notice(URI[scheme => Enum[http, https]] > URI[scheme => 'ftp'])
+        CODE
+      end
+
+      it 'presents parsable string form' do
+        code = <<-CODE
+          notice(URI['https://user:password@www.example.com:3000/some/path?x=y#frag'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq([
+          "URI[{'scheme' => 'https', 'userinfo' => 'user:password', 'host' => 'www.example.com', 'port' => '3000', 'path' => '/some/path', 'query' => 'x=y', 'fragment' => 'frag'}]",
+        ])
+      end
+    end
+
+    context 'a URI instance' do
+      it 'can be created from a string' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice(String($o, '%p'))
+            notice(type($o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq([
+          "URI('https://example.com/a/b')",
+          "URI[{'scheme' => 'https', 'host' => 'example.com', 'path' => '/a/b'}]"
+        ])
+      end
+
+      it 'which is opaque, can be created from a string' do
+        code = <<-CODE
+            $o = URI('urn:a:b:c')
+            notice(String($o, '%p'))
+            notice(type($o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq([
+          "URI('urn:a:b:c')",
+          "URI[{'scheme' => 'urn', 'opaque' => 'a:b:c'}]"
+        ])
+      end
+
+      it 'can be created from a hash' do
+        code = <<-CODE
+            $o = URI(scheme => 'https', host => 'example.com', path => '/a/b')
+            notice(String($o, '%p'))
+            notice(type($o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq([
+          "URI('https://example.com/a/b')",
+          "URI[{'scheme' => 'https', 'host' => 'example.com', 'path' => '/a/b'}]"
+        ])
+      end
+
+      it 'which is opaque, can be created from a hash' do
+        code = <<-CODE
+            $o = URI(scheme => 'urn', opaque => 'a:b:c')
+            notice(String($o, '%p'))
+            notice(type($o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq([
+          "URI('urn:a:b:c')",
+          "URI[{'scheme' => 'urn', 'opaque' => 'a:b:c'}]"
+        ])
+      end
+
+      it 'is an instance of its type' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice($o =~ type($o))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['true'])
+      end
+
+      it 'is an instance of matching parameterized URI' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice($o =~ URI[scheme => https, host => 'example.com'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['true'])
+      end
+
+      it 'is an instance of matching default URI' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice($o =~ URI)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['true'])
+      end
+
+      it 'path is not matched by opaque' do
+        code = <<-CODE
+            $o = URI('urn:a:b:c')
+            notice($o =~ URI[path => 'a:b:c'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['false'])
+      end
+
+      it 'opaque is not matched by path' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice($o =~ URI[opaque => '/a/b'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['false'])
+      end
+
+      it 'is not an instance unless parameters matches' do
+        code = <<-CODE
+            $o = URI('https://example.com/a/b')
+            notice($o =~ URI[scheme => http])
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['false'])
+      end
+
+      it 'individual parts of URI can be accessed using accessor methods' do
+        code = <<-CODE
+            $o = URI('https://bob:pw@example.com:8080/a/b?a=b#frag')
+            notice($o.scheme)
+            notice($o.userinfo)
+            notice($o.host)
+            notice($o.port)
+            notice($o.path)
+            notice($o.query)
+            notice($o.fragment)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['https', 'bob:pw', 'example.com', '8080', '/a/b', 'a=b', 'frag'])
+      end
+
+      it 'individual parts of opaque URI can be accessed using accessor methods' do
+        code = <<-CODE
+            $o = URI('urn:a:b:c')
+            notice($o.scheme)
+            notice($o.opaque)
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(['urn', 'a:b:c'])
+      end
+
+      it 'An URI can be merged with a String using the + operator' do
+        code = <<-CODE
+          notice(String(URI('https://example.com') + '/a/b', '%p'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(["URI('https://example.com/a/b')"])
+      end
+
+      it 'An URI can be merged with another URI using the + operator' do
+        code = <<-CODE
+          notice(String(URI('https://example.com') + URI('/a/b'), '%p'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eq(["URI('https://example.com/a/b')"])
+      end
+    end
+  end
+end
+end
+end

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

@@ -208,53 +208,72 @@ describe 'Puppet Ruby Generator' do
   end
 
   context 'when generating from Object types' do
-    def source
-      <<-CODE
-        type MyModule::FirstGenerated = Object[{
-          attributes => {
-            name => String,
-            age  => { type => Integer, value => 30 },
-            what => { type => String, value => 'what is this', kind => constant },
-            uc_name => {
-              type => String,
-              kind => derived,
-              annotations => {
-                RubyMethod => { body => '@name.upcase' }
+    let (:type_decls) { <<-CODE.unindent }
+      type MyModule::FirstGenerated = Object[{
+        attributes => {
+          name => String,
+          age  => { type => Integer, value => 30 },
+          what => { type => String, value => 'what is this', kind => constant },
+          uc_name => {
+            type => String,
+            kind => derived,
+            annotations => {
+              RubyMethod => { body => '@name.upcase' }
+            }
+          },
+          other_name => {
+            type => String,
+            kind => derived
+          },
+        },
+        functions => {
+          some_other => {
+            type => Callable[1,1]
+          },
+          name_and_age => {
+            type => Callable[1,1],
+            annotations => {
+              RubyMethod => {
+                parameters => 'joiner',
+                body => '"\#{@name}\#{joiner}\#{@age}"'
               }
-            },
-            other_name => {
-              type => String,
-              kind => derived
             }
           },
-          functions => {
-            some_other => {
-              type => Callable[1,1]
-            },
-            name_and_age => {
-              type => Callable[1,1],
-              annotations => {
-                RubyMethod => {
-                  parameters => 'joiner',
-                  body => '"\#{@name}\#{joiner}\#{@age}"'
-                }
+          '[]' => {
+            type => Callable[1,1],
+            annotations => {
+              RubyMethod => {
+                parameters => 'key',
+                body => @(EOF)
+                  case key
+                  when 'name'
+                    name
+                  when 'age'
+                    age
+                  else
+                    nil
+                  end
+                |-EOF
               }
-            },
-          }
-        }]
-        type MyModule::SecondGenerated = Object[{
-          parent => MyModule::FirstGenerated,
-          attributes => {
-            address => String,
-            zipcode => String,
-            email => String,
-            another => { type => Optional[MyModule::FirstGenerated], value => undef },
-            number => Integer,
-            aref => { type => Optional[MyModule::FirstGenerated], value => undef, kind => reference }
+            }
           }
-        }]
+        }
+      }]
+      type MyModule::SecondGenerated = Object[{
+        parent => MyModule::FirstGenerated,
+        attributes => {
+          address => String,
+          zipcode => String,
+          email => String,
+          another => { type => Optional[MyModule::FirstGenerated], value => undef },
+          number => Integer,
+          aref => { type => Optional[MyModule::FirstGenerated], value => undef, kind => reference }
+        }
+      }]
       CODE
-    end
+
+    let(:type_usage) { '' }
+    let(:source) { type_decls + type_usage }
 
     context 'when generating anonymous classes' do
 
@@ -264,11 +283,12 @@ describe 'Puppet Ruby Generator' do
       let(:second_type) { parser.parse('MyModule::SecondGenerated', loader) }
       let(:first) { generator.create_class(first_type) }
       let(:second) { generator.create_class(second_type) }
+      let(:notices) { [] }
 
       before(:each) do
-        eval_and_collect_notices(source) do |topscope|
+        notices.concat(eval_and_collect_notices(source) do |topscope|
           loader = topscope.compiler.loaders.find_loader(nil)
-        end
+        end)
       end
 
       after(:each) { typeset = nil }
@@ -296,6 +316,12 @@ describe 'Puppet Ruby Generator' do
           expect(inst.age).to eq(52)
         end
 
+        it 'created instance has a [] method' do
+          inst = first.create('Bob Builder', 52)
+          expect(inst['name']).to eq('Bob Builder')
+          expect(inst['age']).to eq(52)
+        end
+
         it 'will perform type assertion of the arguments' do
           expect { first.create('Bob Builder', '52') }.to(
             raise_error(TypeAssertionError,
@@ -379,6 +405,18 @@ describe 'Puppet Ruby Generator' do
           expect(results).to eq([inst])
         end
       end
+
+      context 'when used from Puppet' do
+        let(:type_usage) { <<-PUPPET.unindent }
+          $i = MyModule::FirstGenerated('Bob Builder', 52)
+          notice($i['name'])
+          notice($i['age'])
+        PUPPET
+
+        it 'The [] method is present on a created instance' do
+          expect(notices).to eql(['Bob Builder', '52'])
+        end
+      end
     end
 
     context 'when generating static code' do
@@ -576,7 +614,7 @@ describe 'Puppet Ruby Generator' do
               "MyFloat => Float, "+
               "ThirdGenerated => Object[{attributes => {'first' => My::FirstGenerated}}], "+
               "FourthGenerated => Object[{parent => My::SecondGenerated, attributes => {"+
-                "'complex' => {type => Optional[ThirdGenerated], value => ?}, "+
+                "'complex' => {type => Optional[ThirdGenerated], value => undef}, "+
                 "'n1' => My::MyInteger, "+
                 "'n2' => MyFloat"+
               "}}]}, references => {My => {'name' => 'MyModule', 'version_range' => '1.x'}}}]")

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

@@ -0,0 +1,353 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+require 'puppet/parser/script_compiler'
+
+module Puppet::Pops
+module Types
+describe 'The Task Type' do
+  include PuppetSpec::Compiler
+  include PuppetSpec::Files
+
+  context 'when loading' do
+    let(:testing_env) do
+      {
+        'testing' => {
+          'modules' => modules,
+          'manifests' => manifests
+        }
+      }
+    end
+
+    let(:manifests) { {} }
+    let(:environments_dir) { Puppet[:environmentpath] }
+
+    let(:testing_env_dir) do
+      dir_contained_in(environments_dir, testing_env)
+      env_dir = File.join(environments_dir, 'testing')
+      PuppetSpec::Files.record_tmp(env_dir)
+      env_dir
+    end
+
+    let(:modules_dir) { File.join(testing_env_dir, 'modules') }
+    let(:env) { Puppet::Node::Environment.create(:testing, [modules_dir]) }
+    let(:node) { Puppet::Node.new('test', :environment => env) }
+    let(:logs) { [] }
+    let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+    let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
+    let(:task_t) { TypeFactory.task }
+    before(:each) { Puppet[:tasks] = true }
+
+    context 'tasks' do
+      let(:compiler) { Puppet::Parser::ScriptCompiler.new(env, node.name) }
+
+      let(:modules) do
+        { 'testmodule' => testmodule }
+      end
+
+      def compile(code = nil)
+        Puppet[:code] = code
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          compiler.compile do |catalog|
+            yield if block_given?
+            catalog
+          end
+        end
+      end
+
+      context 'without metadata' do
+        let(:testmodule) {
+          {
+            'tasks' => {
+              'hello' => <<-RUBY
+            require 'json'
+            args = JSON.parse(STDIN.read)
+            puts({message: args['message']}.to_json)
+            exit 0
+            RUBY
+            }
+          }
+        }
+
+        it 'loads task without metadata as a generic Task' do
+          compile do
+            module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
+            task = module_loader.load(:task, 'testmodule::hello')
+            expect(task_t.instance?(task)).to be_truthy
+            expect(task.name).to eq('testmodule::hello')
+            expect(task._pcore_type).to eq(task_t)
+          end
+        end
+
+        context 'without --tasks' do
+          before(:each) { Puppet[:tasks] = false }
+
+          it 'evaluator does not recognize generic tasks' do
+            compile do
+              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
+              expect(module_loader.load(:task, 'testmodule::hello')).to be_nil
+            end
+          end
+        end
+      end
+
+      context 'with metadata' do
+        let(:testmodule) {
+          {
+            'tasks' => {
+              'hello.rb' => <<-RUBY,
+                require 'json'
+                args = JSON.parse(STDIN.read)
+                puts({message: args['message']}.to_json)
+                exit 0
+                RUBY
+              'hello.json' => <<-JSON,
+                {
+                  "puppet_task_version": 1,
+                  "supports_noop": true,
+                  "parameters": {
+                     "message": {
+                       "type": "String",
+                       "description": "the message",
+                       "sensitive": false
+                     },
+                     "font": {
+                       "type": "Optional[String]"
+                     }
+                }}
+                JSON
+              'non_data.rb' => <<-RUBY,
+                require 'json'
+                args = JSON.parse(STDIN.read)
+                puts({message: args['message']}.to_json)
+                exit 0
+                RUBY
+              'non_data.json' => <<-JSON
+                {
+                  "puppet_task_version": 1,
+                  "supports_noop": true,
+                  "parameters": {
+                     "arg": {
+                       "type": "Hash",
+                       "description": "the non data param"
+                     }
+                }}
+                JSON
+            }
+          }
+        }
+
+        it 'loads a task with parameters' do
+          compile do
+            module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
+            task = module_loader.load(:task, 'testmodule::hello')
+            expect(task_t.instance?(task)).to be_truthy
+            expect(task.name).to eq('testmodule::hello')
+            expect(task._pcore_type).to eq(task_t)
+            expect(task.supports_noop).to eql(true)
+            expect(task.puppet_task_version).to eql(1)
+            expect(task.executable).to eql("#{modules_dir}/testmodule/tasks/hello.rb")
+
+            tp = task.parameters
+            expect(tp['message']['description']).to eql('the message')
+            expect(tp['message']['type']).to be_a(Puppet::Pops::Types::PStringType)
+          end
+        end
+
+        it 'loads a task with non-Data parameter' do
+          compile do
+            module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
+            task = module_loader.load(:task, 'testmodule::non_data')
+            expect(task_t.instance?(task)).to be_truthy
+            tp = task.parameters
+            expect(tp['arg']['type']).to be_a(Puppet::Pops::Types::PHashType)
+          end
+        end
+
+        context 'with adjacent directory for init task' do
+          let(:testmodule) {
+            {
+              'tasks' => {
+                'init' => {
+                  'foo.sh' => 'echo hello'
+                },
+                'init.sh' => 'echo hello',
+                'init.json' => <<-JSON
+                {
+                  "supports_noop": true,
+                  "parameters": {
+                     "message": { "type": "String" }
+                  }
+                }
+              JSON
+              }
+            }
+          }
+
+          it 'loads the init task with parameters and executable' do
+            compile do
+              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
+              task = module_loader.load(:task, 'testmodule')
+              expect(task_t.instance?(task)).to be_truthy
+              expect(task.executable).to eql("#{modules_dir}/testmodule/tasks/init.sh")
+              expect(task.parameters).to be_a(Hash)
+              expect(task.parameters['message']['type']).to be_a(Puppet::Pops::Types::PStringType)
+            end
+          end
+        end
+
+        context 'with adjacent directory for named task' do
+          let(:testmodule) {
+            {
+              'tasks' => {
+                'hello' => {
+                  'foo.sh' => 'echo hello'
+                },
+                'hello.sh' => 'echo hello',
+                'hello.json' => <<-JSON
+                {
+                  "supports_noop": true,
+                  "parameters": {
+                     "message": { "type": "String" }
+                  }
+                }
+              JSON
+              }
+            }
+          }
+
+          it 'loads a named task with parameters and executable' do
+            compile do
+              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
+              task = module_loader.load(:task, 'testmodule::hello')
+              expect(task_t.instance?(task)).to be_truthy
+              expect(task.executable).to eql("#{modules_dir}/testmodule/tasks/hello.sh")
+              expect(task.parameters).to be_a(Hash)
+              expect(task.parameters['message']['type']).to be_a(Puppet::Pops::Types::PStringType)
+            end
+          end
+        end
+
+        context 'using more than two segments in the name' do
+          let(:testmodule) {
+            {
+              'tasks' => {
+                'hello' => {
+                  'foo.sh' => 'echo hello'
+                }
+              }
+            }
+          }
+
+          it 'task is not found' do
+            compile do
+              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
+              expect(module_loader.load(:task, 'testmodule::hello::foo')).to be_nil
+            end
+          end
+        end
+
+        context 'that has a malformed top-level entry' do
+          let(:testmodule) {
+            {
+              'tasks' => {
+                'hello' => 'echo hello',
+                'hello.json' => <<-JSON
+                {
+                  "supports_nop": true,
+                  "parameters": {
+                     "message": { "type": "String" }
+                  }
+                }
+              JSON
+              }
+            }
+          }
+
+          it 'fails with unrecognized key error' do
+            compile do
+              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
+              expect{module_loader.load(:task, 'testmodule::hello')}.to raise_error(
+                /Failed to load metadata for task testmodule::hello:.*unrecognized key 'supports_nop'/)
+            end
+          end
+        end
+
+        context 'that has no parameters' do
+          let(:testmodule) {
+            {
+              'tasks' => {
+                'hello' => 'echo hello',
+                'hello.json' => '{ "supports_noop": false }'             }
+            }
+          }
+
+          it 'loads the task with parameters set to undef' do
+            compile do
+              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
+              task = module_loader.load(:task, 'testmodule::hello')
+              expect(task_t.instance?(task)).to be_truthy
+              expect(task.parameters).to be_nil
+            end
+          end
+        end
+
+        context 'that has a malformed parameter name' do
+          let(:testmodule) {
+            {
+              'tasks' => {
+                'hello' => 'echo hello',
+                'hello.json' => <<-JSON
+                {
+                  "supports_noop": true,
+                  "parameters": {
+                     "Message": { "type": "String" }
+                  }
+                }
+              JSON
+              }
+            }
+          }
+
+          it 'fails with pattern mismatch error' do
+            compile do
+              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
+              expect{module_loader.load(:task, 'testmodule::hello')}.to raise_error(
+                /entry 'parameters' key of entry 'Message' expects a match for Pattern\[\/\\A\[a-z\]\[a-z0-9_\]\*\\z\/\], got 'Message'/)
+            end
+          end
+        end
+
+        context 'that has a puppet_task_version that is a string' do
+          let(:testmodule) {
+            {
+              'tasks' => {
+                'hello' => 'echo hello',
+                'hello.json' => <<-JSON
+                {
+                  "puppet_task_version": "1",
+                  "supports_noop": true,
+                  "parameters": {
+                     "message": { "type": "String" }
+                  }
+                }
+              JSON
+              }
+            }
+          }
+
+          it 'fails with type mismatch error' do
+            compile do
+              module_loader = Puppet.lookup(:loaders).find_loader('testmodule')
+              expect{module_loader.load(:task, 'testmodule::hello')}.to raise_error(
+                /entry 'puppet_task_version' expects an Integer value, got String/)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+end
+end
+