puppet 4.8.2-x64-mingw32 → 4.9.0-x64-mingw32

data/locales/puppet.pot

@@ -0,0 +1,79 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2017 Puppet, Inc.
+# This file is distributed under the same license as the Puppet automation framework package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2017.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: Puppet automation framework 4.8.2-338-g562b302\n"
+"\n"
+"Report-Msgid-Bugs-To: https://tickets.puppetlabs.com\n"
+"POT-Creation-Date: 2017-01-25 09:32-0800\n"
+"PO-Revision-Date: 2017-01-25 09:32-0800\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\n"
+
+msgid "Apache 2 license; see COPYING"
+msgstr ""
+
+msgid "Display Puppet help."
+msgstr ""
+
+msgid "Display help about Puppet subcommands and their actions."
+msgstr ""
+
+msgid "[<subcommand>] [<action>]"
+msgstr ""
+
+msgid "Short help text for the specified subcommand or action."
+msgstr ""
+
+msgid ""
+"      Get help for an action:\n"
+"\n"
+"      $ puppet help\n"
+msgstr ""
+
+msgid "--version VERSION"
+msgstr ""
+
+msgid "The version of the subcommand for which to show help."
+msgstr ""
+
+msgid "Puppet help only takes two (optional) arguments: a subcommand and an action"
+msgstr ""
+
+msgid "Version only makes sense when a Faces subcommand is given"
+msgstr ""
+
+msgid "Legacy subcommands don't take actions"
+msgstr ""
+
+msgid ""
+"Could not load help for the application #{applicationname}.\n"
+"Please check the error logs for more information.\n"
+"\n"
+"Detail: \"#{detail.message}\"\n"
+msgstr ""
+
+msgid ""
+"Could not load help for the face #{facename}.\n"
+"Please check the error logs for more information.\n"
+"\n"
+"Detail: \"#{detail.message}\"\n"
+msgstr ""
+
+msgid "\"Unable to load action #{actionname} from #{face}\""
+msgstr ""
+
+msgid " (Deprecated)"
+msgstr ""
+
+msgid "! Subcommand unavailable due to error. Check error logs."
+msgstr ""

data/man/man5/puppet.conf.5

@@ -1285,7 +1285,7 @@ Where to retrieve external facts for pluginsync
 What files to ignore when pulling down plugins\.
 .
 .IP "\(bu" 4
-\fIDefault\fR: \.svn CVS \.git
+\fIDefault\fR: \.svn CVS \.git \.hg
 .
 .IP "" 0
 .

data/spec/fixtures/unit/data_providers/environments/hiera_misc/data/common.yaml

@@ -44,3 +44,5 @@ recursive: '%{r1}'
 km_qualified: "Value from qualified interpolation OS = %{os.name}"
 
 km_multi: "cluster/%{literal('%')}{::cluster}/%{literal('%')}{role}"
+
+domain: "-- %{domain} --"

data/spec/fixtures/unit/data_providers/environments/hiera_modules/modules/two/data/common.yaml

@@ -1,4 +1,4 @@
 ---
 lookup_options:
-  roles::devco::packages:
+  two::arg:
     merge: unique

data/spec/fixtures/unit/data_providers/environments/sample/modules/backend/hiera.yaml

@@ -0,0 +1,5 @@
+---
+:version: 4
+:hierarchy:
+  - :name: "Other"
+    :backend: special

data/spec/fixtures/unit/data_providers/environments/sample/modules/backend/lib/puppet/bindings/backend/default.rb

@@ -0,0 +1,9 @@
+Puppet::Bindings.newbindings('backend::default') do
+  # In the default bindings for this module
+  bind {
+    # bind its name to the 'puppet' environment data provider
+    name         'special'
+    in_multibind "puppet::path_based_data_provider_factories"
+    to_instance "PuppetX::Backend::SpecialDataProviderFactory"
+ }
+end

data/spec/fixtures/unit/data_providers/environments/sample/modules/backend/lib/puppet_x/backend/special_data_provider_factory.rb

@@ -0,0 +1,23 @@
+module PuppetX::Backend
+  class SpecialDataProviderFactory < Puppet::Plugins::DataProviders::PathBasedDataProviderFactory
+    def create(name, paths, parent_data_provider)
+      SpecialDataProvider.new(name, paths)
+    end
+
+    def resolve_paths(datadir, declared_paths, paths, lookup_invocation)
+      paths
+    end
+  end
+
+  class SpecialDataProvider < Puppet::Plugins::DataProviders::PathBasedDataProvider
+    def unchecked_lookup(key, lookup_invocation, merge)
+      value = {
+        'backend::test::param_a' => 'module data param_a is 1000',
+        'backend::test::param_b' => 'module data param_b is 2000',
+      }[key]
+      throw :no_such_key if value.nil?
+      value
+    end
+  end
+end
+

data/spec/fixtures/unit/data_providers/environments/sample/modules/backend/manifests/init.pp

@@ -0,0 +1,5 @@
+class backend {
+  class test($param_a = 1, $param_b = 2, $param_c = 3) {
+    notice("$param_a, $param_b, $param_c")
+  }
+}

data/spec/fixtures/unit/data_providers/environments/sample/modules/backend/metadata.json

@@ -0,0 +1,9 @@
+{
+    "name": "example/one",
+    "version": "0.0.2",
+    "source": "git@github.com/example/example-one.git",
+    "dependencies": [],
+    "author": "Bob the Builder",
+    "license": "Apache-2.0",
+    "data_provider": "hiera"
+}

data/spec/fixtures/unit/data_providers/environments/sample/modules/dataprovider/lib/puppet_x/helindbe/sample_env_data.rb

@@ -19,6 +19,7 @@ module PuppetX::Helindbe
         'test::param_a' => 'env data param_a is 10',
         'test::param_b' => 'env data param_b is 20',
         # demo: this overrides a parameter for a class in the dataprovider module
+        'backend::test::param_c' => 'env data param_c is 3000',
         'dataprovider::test::param_c' => 'env data param_c is 300',
       }
     end

data/spec/fixtures/unit/data_providers/environments/sample/modules/dataprovider/manifests/init.pp

@@ -1,5 +1,5 @@
 class dataprovider {
   class test($param_a = 1, $param_b = 2, $param_c = 3) {
-    notify { "$param_a, $param_b, $param_c": }
+    notice("$param_a, $param_b, $param_c")
   }
 }

data/spec/fixtures/unit/functions/lookup/data/common.yaml

@@ -0,0 +1,19 @@
+---
+abc::a: global_a
+abc::c:
+  - global_c
+
+abc::e:
+  k1: global_e1
+
+abc::f:
+  k1:
+    s1: global_f11
+  k2:
+    s3: global_f23
+
+bca::e:
+  k1: global_e1
+
+no_provider::e:
+  k1: global_e1

data/spec/fixtures/unit/functions/lookup_fixture/data/common.yaml

@@ -0,0 +1,19 @@
+---
+abc::a: global_a
+abc::c:
+  - global_c
+
+abc::e:
+  k1: global_e1
+
+abc::f:
+  k1:
+    s1: global_f11
+  k2:
+    s3: global_f23
+
+bca::e:
+  k1: global_e1
+
+no_provider::e:
+  k1: global_e1

data/spec/integration/application/apply_spec.rb

@@ -134,6 +134,92 @@ end
     end
   end
 
+  context 'from environment with pcore object types' do
+    include PuppetSpec::Compiler
+
+    let!(:envdir) { Puppet[:environmentpath] }
+    let(:env_name) { 'spec' }
+    let(:dir_structure) {
+      {
+        'environment.conf' => <<-CONF,
+          rich_data = true
+        CONF
+        'modules' => {
+          'mod' => {
+            'types' => {
+              'streetaddress.pp' => <<-PUPPET,
+                type Mod::StreetAddress = Object[{
+                  attributes => {
+                    'street' => String,
+                    'zipcode' => String,
+                    'city' => String,
+                  } 
+                }]
+              PUPPET
+              'address.pp' => <<-PUPPET,
+                type Mod::Address = Object[{
+                  parent => Mod::StreetAddress,
+                  attributes => {
+                    'state' => String
+                  } 
+                }]
+              PUPPET
+              'contact.pp' => <<-PUPPET,
+                type Mod::Contact = Object[{
+                  attributes => {
+                    'address' => Mod::Address,
+                    'email' => String
+                  }
+                }]
+              PUPPET
+            },
+            'manifests' => {
+              'init.pp' => <<-PUPPET,
+                define mod::person(Mod::Contact $contact) {
+                  notify { $title: }
+                  notify { $contact.address.street: }
+                  notify { $contact.address.zipcode: }
+                  notify { $contact.address.city: }
+                  notify { $contact.address.state: }
+                }
+
+                class mod {
+                  mod::person { 'Test Person':
+                    contact => Mod::Contact(
+                      Mod::Address('The Street 23', '12345', 'Some City', 'A State'),
+                      'test@example.com')
+                  }
+                }
+              PUPPET
+            }
+          }
+        }
+      }
+    }
+
+    let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(envdir, env_name, 'modules')]) }
+    let(:node) { Puppet::Node.new('test', :environment => env) }
+
+    before(:each) do
+      dir_contained_in(envdir, env_name => dir_structure)
+      PuppetSpec::Files.record_tmp(File.join(envdir, env_name))
+    end
+
+    it 'can compile the catalog' do
+      compile_to_catalog('include mod', node)
+    end
+
+    it 'can apply the catalog' do
+      catalog = compile_to_catalog('include mod', node)
+
+      Puppet[:environment] = env_name
+      apply = Puppet::Application[:apply]
+      apply.options[:catalog] = file_containing('manifest', catalog.to_pson)
+      expect { apply.run_command; exit(0) }.to exit_with(0)
+      expect(@logs.map(&:to_s)).to include('The Street 23')
+    end
+  end
+
   it "applies a given file even when a directory environment is specified" do
     manifest = file_containing("manifest.pp", "notice('it was applied')")
 
@@ -414,8 +500,8 @@ class amod::bad_type {
         apply.expects(:apply_catalog).with do |catalog|
           catalog.resource(:notify, 'rx')['message'].is_a?(Regexp)
           catalog.resource(:notify, 'bin')['message'].is_a?(Puppet::Pops::Types::PBinaryType::Binary)
-          catalog.resource(:notify, 'ver')['message'].is_a?(Semantic::Version)
-          catalog.resource(:notify, 'vrange')['message'].is_a?(Semantic::VersionRange)
+          catalog.resource(:notify, 'ver')['message'].is_a?(SemanticPuppet::Version)
+          catalog.resource(:notify, 'vrange')['message'].is_a?(SemanticPuppet::VersionRange)
           catalog.resource(:notify, 'tspan')['message'].is_a?(Puppet::Pops::Time::Timespan)
           catalog.resource(:notify, 'tstamp')['message'].is_a?(Puppet::Pops::Time::Timestamp)
         end

data/spec/integration/application/lookup_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet_spec/compiler'
+require 'deep_merge/core'
+
+describe 'lookup' do
+  include PuppetSpec::Files
+
+  context 'with an environment' do
+    let(:env_name) { 'spec' }
+    let(:env_dir) { tmpdir('environments') }
+    let(:environment_files) do
+      {
+        env_name => {
+          'modules' => {},
+          'hiera.yaml' => <<-YAML.unindent,
+            ---
+            version: 5
+            hierarchy:
+              - name: "Common"
+                data_hash: yaml_data
+                path: "common.yaml"
+            YAML
+          'data' => {
+            'common.yaml' => <<-YAML.unindent
+              ---
+              a: value a
+              mod_a::a: value mod_a::a (from environment)
+              mod_a::hash_a:
+                a: value mod_a::hash_a.a (from environment)
+              mod_a::hash_b:
+                a: value mod_a::hash_b.a (from environment)
+              lookup_options:
+                mod_a::hash_b:
+                  merge: hash
+              YAML
+          }
+        },
+        'someother' => {
+        }
+      }
+    end
+
+    let(:app) { Puppet::Application[:lookup] }
+    let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, env_name, 'modules')]) }
+    let(:environments) { Puppet::Environments::Directories.new(populated_env_dir, []) }
+
+    let(:populated_env_dir) do
+      dir_contained_in(env_dir, environment_files)
+      env_dir
+    end
+
+    def lookup(key, options = {}, explain = false)
+      key = [key] unless key.is_a?(Array)
+      app.command_line.stubs(:args).returns(key)
+      if explain
+        app.options[:explain] = true
+        app.options[:render_as] = :s
+      else
+        app.options[:render_as] = :json
+      end
+      options.each_pair { |k, v| app.options[k] = v }
+      capture = StringIO.new
+      saved_stdout = $stdout
+      begin
+        $stdout = capture
+        expect { app.run_command }.to exit_with(0)
+      ensure
+        $stdout = saved_stdout
+      end
+      out = capture.string.strip
+      if explain
+        out
+      else
+        out.empty? ? nil : JSON.parse("[#{out}]")[0]
+      end
+    end
+
+    def explain(key, options = {})
+      lookup(key, options, true)
+    end
+
+    around(:each) do |example|
+      Puppet.override(:environments => environments, :current_environment => env) do
+        example.run
+      end
+    end
+
+    it 'finds data in the environment' do
+      expect(lookup('a')).to eql('value a')
+    end
+
+    context 'configured with the wrong environment' do
+      let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, env_name, 'modules')]) }
+      it 'does not find data in non-existing environment' do
+        Puppet.override(:environments => environments, :current_environment => 'someother') do
+          expect(lookup('a', {}, true)).to match(/did not find a value for the name 'a'/)
+        end
+      end
+    end
+
+    context 'and a module' do
+      let(:mod_a_files) do
+        {
+          'mod_a' => {
+            'data' => {
+              'common.yaml' => <<-YAML.unindent
+                ---
+                mod_a::a: value mod_a::a (from mod_a)
+                mod_a::b: value mod_a::b (from mod_a)
+                mod_a::hash_a:
+                  a: value mod_a::hash_a.a (from mod_a)
+                  b: value mod_a::hash_a.b (from mod_a)
+                mod_a::hash_b:
+                  a: value mod_a::hash_b.a (from mod_a)
+                  b: value mod_a::hash_b.b (from mod_a)
+                mod_a::interpolated: "-- %{lookup('mod_a::a')} --"
+                mod_a::a_a: "-- %{lookup('mod_a::hash_a.a')} --"
+                mod_a::a_b: "-- %{lookup('mod_a::hash_a.b')} --"
+                mod_a::b_a: "-- %{lookup('mod_a::hash_b.a')} --"
+                mod_a::b_b: "-- %{lookup('mod_a::hash_b.b')} --"
+                'mod_a::a.quoted.key': 'value mod_a::a.quoted.key (from mod_a)'
+                YAML
+            },
+            'hiera.yaml' => <<-YAML.unindent,
+              ---
+              version: 5
+              hierarchy:
+                - name: "Common"
+                  data_hash: yaml_data
+                  path: "common.yaml"
+              YAML
+          }
+        }
+      end
+
+      let(:populated_env_dir) do
+        dir_contained_in(env_dir, DeepMerge.deep_merge!(environment_files, env_name => { 'modules' => mod_a_files }))
+        env_dir
+      end
+
+      it 'finds data in the module' do
+        expect(lookup('mod_a::b')).to eql('value mod_a::b (from mod_a)')
+      end
+
+      it 'finds quoted keys in the module' do
+        expect(lookup('"mod_a::a.quoted.key"')).to eql('value mod_a::a.quoted.key (from mod_a)')
+      end
+
+      it 'merges hashes from environment and module when merge strategy hash is used' do
+        expect(lookup('mod_a::hash_a', :merge => 'hash')).to eql({'a' => 'value mod_a::hash_a.a (from environment)', 'b' => 'value mod_a::hash_a.b (from mod_a)'})
+      end
+    end
+  end
+end