forge "http://forge.puppetlabs.com"
-#mod 'puppetlabs/stdlib', '4.5.1'
#mod 'puppetlabs/rabbitmq', '5.1.0'
#mod 'puppetlabs/xinetd', '1.5.0'
#mod 'puppetlabs/stunnel', '0.1.0'
+mod 'puppetlabs/stdlib', '4.6.0'
mod 'puppetlabs/concat', '2.0.0'
mod 'elasticsearch/elasticsearch', '0.9.5'
--- /dev/null
+##2015-04-14 - Supported Release 4.6.0
+###Summary
+
+Adds functions and function argument abilities, and improves compatibility with the new puppet parser
+
+####Features
+- MODULES-444: `concat()` can now take more than two arrays
+- `basename()` added to have Ruby File.basename functionality
+- `delete()` can now take an array of items to remove
+- `prefix()` can now take a hash
+- `upcase()` can now take a hash or array of upcaseable things
+- `validate_absolute_path()` can now take an array
+- `validate_cmd()` can now use % in the command to embed the validation file argument in the string
+- MODULES-1473: deprecate `type()` function in favor of `type3x()`
+- MODULES-1473: Add `type_of()` to give better time information on future parser
+- Deprecate `private()` for `assert_private()` due to future parser
+- Adds `ceiling()` to take the ceiling of a number
+- Adds `fqdn_rand_string()` to generate random string based on fqdn
+- Adds `pw_hash()` to generate password hashes
+- Adds `validate_integer()`
+- Adds `validate_numeric()` (like `validate_integer()` but also accepts floats)
+
+####Bugfixes
+- Fix seeding of `fqdn_rotate()`
+- `ensure_resource()` is more verbose on debug mode
+- Stricter argument checking for `dirname()`
+- Fix `is_domain_name()` to better match RFC
+- Fix `uriescape()` when called with array
+- Fix `file_line` resource when using the `after` attribute with `match`
+
+##2015-01-14 - Supported Release 4.5.1
+###Summary
+
+This release changes the temporary facter_dot_d cache locations outside of the /tmp directory due to a possible security vunerability. CVE-2015-1029
+
+####Bugfixes
+- Facter_dot_d cache will now be stored in puppet libdir instead of tmp
+
+##2014-12-15 - Supported Release 4.5.0
+###Summary
+
+This release improves functionality of the member function and adds improved future parser support.
+
+####Features
+- MODULES-1329: Update member() to allow the variable to be an array.
+- Sync .travis.yml, Gemfile, Rakefile, and CONTRIBUTING.md via modulesync
+
+####Bugfixes
+- Fix range() to work with numeric ranges with the future parser
+- Accurately express SLES support in metadata.json (was missing 10SP4 and 12)
+- Don't require `line` to match the `match` parameter
+
+##2014-11-10 - Supported Release 4.4.0
+###Summary
+This release has an overhauled readme, new private manifest function, and fixes many future parser bugs.
+
+####Features
+- All new shiny README
+- New `private()` function for making private manifests (yay!)
+
+####Bugfixes
+- Code reuse in `bool2num()` and `zip()`
+- Fix many functions to handle `generate()` no longer returning a string on new puppets
+- `concat()` no longer modifies the first argument (whoops)
+- strict variable support for `getvar()`, `member()`, `values_at`, and `has_interface_with()`
+- `to_bytes()` handles PB and EB now
+- Fix `tempfile` ruby requirement for `validate_augeas()` and `validate_cmd()`
+- Fix `validate_cmd()` for windows
+- Correct `validate_string()` docs to reflect non-handling of `undef`
+- Fix `file_line` matching on older rubies
+
+
+##2014-07-15 - Supported Release 4.3.2
+###Summary
+
+This release merely updates metadata.json so the module can be uninstalled and
+upgraded via the puppet module command.
+
+##2014-07-14 - Supported Release 4.3.1
+### Summary
+This supported release updates the metadata.json to work around upgrade behavior of the PMT.
+
+#### Bugfixes
+- Synchronize metadata.json with PMT-generated metadata to pass checksums
+
+##2014-06-27 - Supported Release 4.3.0
+### Summary
+This release is the first supported release of the stdlib 4 series. It remains
+backwards-compatible with the stdlib 3 series. It adds two new functions, one bugfix, and many testing updates.
+
+#### Features
+- New `bool2str()` function
+- New `camalcase()` function
+
+#### Bugfixes
+- Fix `has_interface_with()` when interfaces fact is nil
+
+##2014-06-04 - Release 4.2.2
+### Summary
+
+This release adds PE3.3 support in the metadata and fixes a few tests.
+
+## 2014-05-08 - Release - 4.2.1
+### Summary
+This release moves a stray symlink that can cause problems.
+
+## 2014-05-08 - Release - 4.2.0
+### Summary
+This release adds many new functions and fixes, and continues to be backwards compatible with stdlib 3.x
+
+#### Features
+- New `base64()` function
+- New `deep_merge()` function
+- New `delete_undef_values()` function
+- New `delete_values()` function
+- New `difference()` function
+- New `intersection()` function
+- New `is_bool()` function
+- New `pick_default()` function
+- New `union()` function
+- New `validate_ipv4_address` function
+- New `validate_ipv6_address` function
+- Update `ensure_packages()` to take an option hash as a second parameter.
+- Update `range()` to take an optional third argument for range step
+- Update `validate_slength()` to take an optional third argument for minimum length
+- Update `file_line` resource to take `after` and `multiple` attributes
+
+#### Bugfixes
+- Correct `is_string`, `is_domain_name`, `is_array`, `is_float`, and `is_function_available` for parsing odd types such as bools and hashes.
+- Allow facts.d facts to contain `=` in the value
+- Fix `root_home` fact on darwin systems
+- Fix `concat()` to work with a second non-array argument
+- Fix `floor()` to work with integer strings
+- Fix `is_integer()` to return true if passed integer strings
+- Fix `is_numeric()` to return true if passed integer strings
+- Fix `merge()` to work with empty strings
+- Fix `pick()` to raise the correct error type
+- Fix `uriescape()` to use the default URI.escape list
+- Add/update unit & acceptance tests.
+
+
+##2014-03-04 - Supported Release - 3.2.1
+###Summary
+This is a supported release
+
+####Bugfixes
+- Fixed `is_integer`/`is_float`/`is_numeric` for checking the value of arithmatic expressions.
+
+####Known bugs
+* No known bugs
+
+---
+
+##### 2013-05-06 - Jeff McCune <jeff@puppetlabs.com> - 4.1.0
+
+ * (#20582) Restore facter\_dot\_d to stdlib for PE users (3b887c8)
+ * (maint) Update Gemfile with GEM\_FACTER\_VERSION (f44d535)
+
+##### 2013-05-06 - Alex Cline <acline@us.ibm.com> - 4.1.0
+
+ * Terser method of string to array conversion courtesy of ethooz. (d38bce0)
+
+##### 2013-05-06 - Alex Cline <acline@us.ibm.com> 4.1.0
+
+ * Refactor ensure\_resource expectations (b33cc24)
+
+##### 2013-05-06 - Alex Cline <acline@us.ibm.com> 4.1.0
+
+ * Changed str-to-array conversion and removed abbreviation. (de253db)
+
+##### 2013-05-03 - Alex Cline <acline@us.ibm.com> 4.1.0
+
+ * (#20548) Allow an array of resource titles to be passed into the ensure\_resource function (e08734a)
+
+##### 2013-05-02 - Raphaël Pinson <raphael.pinson@camptocamp.com> - 4.1.0
+
+ * Add a dirname function (2ba9e47)
+
+##### 2013-04-29 - Mark Smith-Guerrero <msmithgu@gmail.com> - 4.1.0
+
+ * (maint) Fix a small typo in hash() description (928036a)
+
+##### 2013-04-12 - Jeff McCune <jeff@puppetlabs.com> - 4.0.2
+
+ * Update user information in gemspec to make the intent of the Gem clear.
+
+##### 2013-04-11 - Jeff McCune <jeff@puppetlabs.com> - 4.0.1
+
+ * Fix README function documentation (ab3e30c)
+
+##### 2013-04-11 - Jeff McCune <jeff@puppetlabs.com> - 4.0.0
+
+ * stdlib 4.0 drops support with Puppet 2.7
+ * stdlib 4.0 preserves support with Puppet 3
+
+##### 2013-04-11 - Jeff McCune <jeff@puppetlabs.com> - 4.0.0
+
+ * Add ability to use puppet from git via bundler (9c5805f)
+
+##### 2013-04-10 - Jeff McCune <jeff@puppetlabs.com> - 4.0.0
+
+ * (maint) Make stdlib usable as a Ruby GEM (e81a45e)
+
+##### 2013-04-10 - Erik Dalén <dalen@spotify.com> - 4.0.0
+
+ * Add a count function (f28550e)
+
+##### 2013-03-31 - Amos Shapira <ashapira@atlassian.com> - 4.0.0
+
+ * (#19998) Implement any2array (7a2fb80)
+
+##### 2013-03-29 - Steve Huff <shuff@vecna.org> - 4.0.0
+
+ * (19864) num2bool match fix (8d217f0)
+
+##### 2013-03-20 - Erik Dalén <dalen@spotify.com> - 4.0.0
+
+ * Allow comparisons of Numeric and number as String (ff5dd5d)
+
+##### 2013-03-26 - Richard Soderberg <rsoderberg@mozilla.com> - 4.0.0
+
+ * add suffix function to accompany the prefix function (88a93ac)
+
+##### 2013-03-19 - Kristof Willaert <kristof.willaert@gmail.com> - 4.0.0
+
+ * Add floor function implementation and unit tests (0527341)
+
+##### 2012-04-03 - Eric Shamow <eric@puppetlabs.com> - 4.0.0
+
+ * (#13610) Add is\_function\_available to stdlib (961dcab)
+
+##### 2012-12-17 - Justin Lambert <jlambert@eml.cc> - 4.0.0
+
+ * str2bool should return a boolean if called with a boolean (5d5a4d4)
+
+##### 2012-10-23 - Uwe Stuehler <ustuehler@team.mobile.de> - 4.0.0
+
+ * Fix number of arguments check in flatten() (e80207b)
+
+##### 2013-03-11 - Jeff McCune <jeff@puppetlabs.com> - 4.0.0
+
+ * Add contributing document (96e19d0)
+
+##### 2013-03-04 - Raphaël Pinson <raphael.pinson@camptocamp.com> - 4.0.0
+
+ * Add missing documentation for validate\_augeas and validate\_cmd to README.markdown (a1510a1)
+
+##### 2013-02-14 - Joshua Hoblitt <jhoblitt@cpan.org> - 4.0.0
+
+ * (#19272) Add has\_element() function (95cf3fe)
+
+##### 2013-02-07 - Raphaël Pinson <raphael.pinson@camptocamp.com> - 4.0.0
+
+ * validate\_cmd(): Use Puppet::Util::Execution.execute when available (69248df)
+
+##### 2012-12-06 - Raphaël Pinson <raphink@gmail.com> - 4.0.0
+
+ * Add validate\_augeas function (3a97c23)
+
+##### 2012-12-06 - Raphaël Pinson <raphink@gmail.com> - 4.0.0
+
+ * Add validate\_cmd function (6902cc5)
+
+##### 2013-01-14 - David Schmitt <david@dasz.at> - 4.0.0
+
+ * Add geppetto project definition (b3fc0a3)
+
+##### 2013-01-02 - Jaka Hudoklin <jakahudoklin@gmail.com> - 4.0.0
+
+ * Add getparam function to get defined resource parameters (20e0e07)
+
+##### 2013-01-05 - Jeff McCune <jeff@puppetlabs.com> - 4.0.0
+
+ * (maint) Add Travis CI Support (d082046)
+
+##### 2012-12-04 - Jeff McCune <jeff@puppetlabs.com> - 4.0.0
+
+ * Clarify that stdlib 3 supports Puppet 3 (3a6085f)
+
+##### 2012-11-30 - Erik Dalén <dalen@spotify.com> - 4.0.0
+
+ * maint: style guideline fixes (7742e5f)
+
+##### 2012-11-09 - James Fryman <james@frymanet.com> - 4.0.0
+
+ * puppet-lint cleanup (88acc52)
+
+##### 2012-11-06 - Joe Julian <me@joejulian.name> - 4.0.0
+
+ * Add function, uriescape, to URI.escape strings. Redmine #17459 (fd52b8d)
+
+##### 2012-09-18 - Chad Metcalf <chad@wibidata.com> - 3.2.0
+
+ * Add an ensure\_packages function. (8a8c09e)
+
+##### 2012-11-23 - Erik Dalén <dalen@spotify.com> - 3.2.0
+
+ * (#17797) min() and max() functions (9954133)
+
+##### 2012-05-23 - Peter Meier <peter.meier@immerda.ch> - 3.2.0
+
+ * (#14670) autorequire a file\_line resource's path (dfcee63)
+
+##### 2012-11-19 - Joshua Harlan Lifton <lifton@puppetlabs.com> - 3.2.0
+
+ * Add join\_keys\_to\_values function (ee0f2b3)
+
+##### 2012-11-17 - Joshua Harlan Lifton <lifton@puppetlabs.com> - 3.2.0
+
+ * Extend delete function for strings and hashes (7322e4d)
+
+##### 2012-08-03 - Gary Larizza <gary@puppetlabs.com> - 3.2.0
+
+ * Add the pick() function (ba6dd13)
+
+##### 2012-03-20 - Wil Cooley <wcooley@pdx.edu> - 3.2.0
+
+ * (#13974) Add predicate functions for interface facts (f819417)
+
+##### 2012-11-06 - Joe Julian <me@joejulian.name> - 3.2.0
+
+ * Add function, uriescape, to URI.escape strings. Redmine #17459 (70f4a0e)
+
+##### 2012-10-25 - Jeff McCune <jeff@puppetlabs.com> - 3.1.1
+
+ * (maint) Fix spec failures resulting from Facter API changes (97f836f)
+
+##### 2012-10-23 - Matthaus Owens <matthaus@puppetlabs.com> - 3.1.0
+
+ * Add PE facts to stdlib (cdf3b05)
+
+##### 2012-08-16 - Jeff McCune <jeff@puppetlabs.com> - 3.0.1
+
+ * Fix accidental removal of facts\_dot\_d.rb in 3.0.0 release
+
+##### 2012-08-16 - Jeff McCune <jeff@puppetlabs.com> - 3.0.0
+
+ * stdlib 3.0 drops support with Puppet 2.6
+ * stdlib 3.0 preserves support with Puppet 2.7
+
+##### 2012-08-07 - Dan Bode <dan@puppetlabs.com> - 3.0.0
+
+ * Add function ensure\_resource and defined\_with\_params (ba789de)
+
+##### 2012-07-10 - Hailee Kenney <hailee@puppetlabs.com> - 3.0.0
+
+ * (#2157) Remove facter\_dot\_d for compatibility with external facts (f92574f)
+
+##### 2012-04-10 - Chris Price <chris@puppetlabs.com> - 3.0.0
+
+ * (#13693) moving logic from local spec\_helper to puppetlabs\_spec\_helper (85f96df)
+
+##### 2012-10-25 - Jeff McCune <jeff@puppetlabs.com> - 2.5.1
+
+ * (maint) Fix spec failures resulting from Facter API changes (97f836f)
+
+##### 2012-10-23 - Matthaus Owens <matthaus@puppetlabs.com> - 2.5.0
+
+ * Add PE facts to stdlib (cdf3b05)
+
+##### 2012-08-15 - Dan Bode <dan@puppetlabs.com> - 2.5.0
+
+ * Explicitly load functions used by ensure\_resource (9fc3063)
+
+##### 2012-08-13 - Dan Bode <dan@puppetlabs.com> - 2.5.0
+
+ * Add better docs about duplicate resource failures (97d327a)
+
+##### 2012-08-13 - Dan Bode <dan@puppetlabs.com> - 2.5.0
+
+ * Handle undef for parameter argument (4f8b133)
+
+##### 2012-08-07 - Dan Bode <dan@puppetlabs.com> - 2.5.0
+
+ * Add function ensure\_resource and defined\_with\_params (a0cb8cd)
+
+##### 2012-08-20 - Jeff McCune <jeff@puppetlabs.com> - 2.5.0
+
+ * Disable tests that fail on 2.6.x due to #15912 (c81496e)
+
+##### 2012-08-20 - Jeff McCune <jeff@puppetlabs.com> - 2.5.0
+
+ * (Maint) Fix mis-use of rvalue functions as statements (4492913)
+
+##### 2012-08-20 - Jeff McCune <jeff@puppetlabs.com> - 2.5.0
+
+ * Add .rspec file to repo root (88789e8)
+
+##### 2012-06-07 - Chris Price <chris@puppetlabs.com> - 2.4.0
+
+ * Add support for a 'match' parameter to file\_line (a06c0d8)
+
+##### 2012-08-07 - Erik Dalén <dalen@spotify.com> - 2.4.0
+
+ * (#15872) Add to\_bytes function (247b69c)
+
+##### 2012-07-19 - Jeff McCune <jeff@puppetlabs.com> - 2.4.0
+
+ * (Maint) use PuppetlabsSpec::PuppetInternals.scope (master) (deafe88)
+
+##### 2012-07-10 - Hailee Kenney <hailee@puppetlabs.com> - 2.4.0
+
+ * (#2157) Make facts\_dot\_d compatible with external facts (5fb0ddc)
+
+##### 2012-03-16 - Steve Traylen <steve.traylen@cern.ch> - 2.4.0
+
+ * (#13205) Rotate array/string randomley based on fqdn, fqdn\_rotate() (fef247b)
+
+##### 2012-05-22 - Peter Meier <peter.meier@immerda.ch> - 2.3.3
+
+ * fix regression in #11017 properly (f0a62c7)
+
+##### 2012-05-10 - Jeff McCune <jeff@puppetlabs.com> - 2.3.3
+
+ * Fix spec tests using the new spec\_helper (7d34333)
+
+##### 2012-05-10 - Puppet Labs <support@puppetlabs.com> - 2.3.2
+
+ * Make file\_line default to ensure => present (1373e70)
+ * Memoize file\_line spec instance variables (20aacc5)
+ * Fix spec tests using the new spec\_helper (1ebfa5d)
+ * (#13595) initialize\_everything\_for\_tests couples modules Puppet ver (3222f35)
+ * (#13439) Fix MRI 1.9 issue with spec\_helper (15c5fd1)
+ * (#13439) Fix test failures with Puppet 2.6.x (665610b)
+ * (#13439) refactor spec helper for compatibility with both puppet 2.7 and master (82194ca)
+ * (#13494) Specify the behavior of zero padded strings (61891bb)
+
+##### 2012-03-29 Puppet Labs <support@puppetlabs.com> - 2.1.3
+
+* (#11607) Add Rakefile to enable spec testing
+* (#12377) Avoid infinite loop when retrying require json
+
+##### 2012-03-13 Puppet Labs <support@puppetlabs.com> - 2.3.1
+
+* (#13091) Fix LoadError bug with puppet apply and puppet\_vardir fact
+
+##### 2012-03-12 Puppet Labs <support@puppetlabs.com> - 2.3.0
+
+* Add a large number of new Puppet functions
+* Backwards compatibility preserved with 2.2.x
+
+##### 2011-12-30 Puppet Labs <support@puppetlabs.com> - 2.2.1
+
+* Documentation only release for the Forge
+
+##### 2011-12-30 Puppet Labs <support@puppetlabs.com> - 2.1.2
+
+* Documentation only release for PE 2.0.x
+
+##### 2011-11-08 Puppet Labs <support@puppetlabs.com> - 2.2.0
+
+* #10285 - Refactor json to use pson instead.
+* Maint - Add watchr autotest script
+* Maint - Make rspec tests work with Puppet 2.6.4
+* #9859 - Add root\_home fact and tests
+
+##### 2011-08-18 Puppet Labs <support@puppetlabs.com> - 2.1.1
+
+* Change facts.d paths to match Facter 2.0 paths.
+* /etc/facter/facts.d
+* /etc/puppetlabs/facter/facts.d
+
+##### 2011-08-17 Puppet Labs <support@puppetlabs.com> - 2.1.0
+
+* Add R.I. Pienaar's facts.d custom facter fact
+* facts defined in /etc/facts.d and /etc/puppetlabs/facts.d are
+ automatically loaded now.
+
+##### 2011-08-04 Puppet Labs <support@puppetlabs.com> - 2.0.0
+
+* Rename whole\_line to file\_line
+* This is an API change and as such motivating a 2.0.0 release according to semver.org.
+
+##### 2011-08-04 Puppet Labs <support@puppetlabs.com> - 1.1.0
+
+* Rename append\_line to whole\_line
+* This is an API change and as such motivating a 1.1.0 release.
+
+##### 2011-08-04 Puppet Labs <support@puppetlabs.com> - 1.0.0
+
+* Initial stable release
+* Add validate\_array and validate\_string functions
+* Make merge() function work with Ruby 1.8.5
+* Add hash merging function
+* Add has\_key function
+* Add loadyaml() function
+* Add append\_line native
+
+##### 2011-06-21 Jeff McCune <jeff@puppetlabs.com> - 0.1.7
+
+* Add validate\_hash() and getvar() functions
+
+##### 2011-06-15 Jeff McCune <jeff@puppetlabs.com> - 0.1.6
+
+* Add anchor resource type to provide containment for composite classes
+
+##### 2011-06-03 Jeff McCune <jeff@puppetlabs.com> - 0.1.5
+
+* Add validate\_bool() function to stdlib
+
+##### 0.1.4 2011-05-26 Jeff McCune <jeff@puppetlabs.com>
+
+* Move most stages after main
+
+##### 0.1.3 2011-05-25 Jeff McCune <jeff@puppetlabs.com>
+
+* Add validate\_re() function
+
+##### 0.1.2 2011-05-24 Jeff McCune <jeff@puppetlabs.com>
+
+* Update to add annotated tag
+
+##### 0.1.1 2011-05-24 Jeff McCune <jeff@puppetlabs.com>
+
+* Add stdlib::stages class with a standard set of stages
--- /dev/null
+Checklist (and a short version for the impatient)
+=================================================
+
+ * Commits:
+
+ - Make commits of logical units.
+
+ - Check for unnecessary whitespace with "git diff --check" before
+ committing.
+
+ - Commit using Unix line endings (check the settings around "crlf" in
+ git-config(1)).
+
+ - Do not check in commented out code or unneeded files.
+
+ - The first line of the commit message should be a short
+ description (50 characters is the soft limit, excluding ticket
+ number(s)), and should skip the full stop.
+
+ - Associate the issue in the message. The first line should include
+ the issue number in the form "(#XXXX) Rest of message".
+
+ - The body should provide a meaningful commit message, which:
+
+ - uses the imperative, present tense: "change", not "changed" or
+ "changes".
+
+ - includes motivation for the change, and contrasts its
+ implementation with the previous behavior.
+
+ - Make sure that you have tests for the bug you are fixing, or
+ feature you are adding.
+
+ - Make sure the test suites passes after your commit:
+ `bundle exec rspec spec/acceptance` More information on [testing](#Testing) below
+
+ - When introducing a new feature, make sure it is properly
+ documented in the README.md
+
+ * Submission:
+
+ * Pre-requisites:
+
+ - Make sure you have a [GitHub account](https://github.com/join)
+
+ - [Create a ticket](https://tickets.puppetlabs.com/secure/CreateIssue!default.jspa), or [watch the ticket](https://tickets.puppetlabs.com/browse/) you are patching for.
+
+ * Preferred method:
+
+ - Fork the repository on GitHub.
+
+ - Push your changes to a topic branch in your fork of the
+ repository. (the format ticket/1234-short_description_of_change is
+ usually preferred for this project).
+
+ - Submit a pull request to the repository in the puppetlabs
+ organization.
+
+The long version
+================
+
+ 1. Make separate commits for logically separate changes.
+
+ Please break your commits down into logically consistent units
+ which include new or changed tests relevant to the rest of the
+ change. The goal of doing this is to make the diff easier to
+ read for whoever is reviewing your code. In general, the easier
+ your diff is to read, the more likely someone will be happy to
+ review it and get it into the code base.
+
+ If you are going to refactor a piece of code, please do so as a
+ separate commit from your feature or bug fix changes.
+
+ We also really appreciate changes that include tests to make
+ sure the bug is not re-introduced, and that the feature is not
+ accidentally broken.
+
+ Describe the technical detail of the change(s). If your
+ description starts to get too long, that is a good sign that you
+ probably need to split up your commit into more finely grained
+ pieces.
+
+ Commits which plainly describe the things which help
+ reviewers check the patch and future developers understand the
+ code are much more likely to be merged in with a minimum of
+ bike-shedding or requested changes. Ideally, the commit message
+ would include information, and be in a form suitable for
+ inclusion in the release notes for the version of Puppet that
+ includes them.
+
+ Please also check that you are not introducing any trailing
+ whitespace or other "whitespace errors". You can do this by
+ running "git diff --check" on your changes before you commit.
+
+ 2. Sending your patches
+
+ To submit your changes via a GitHub pull request, we _highly_
+ recommend that you have them on a topic branch, instead of
+ directly on "master".
+ It makes things much easier to keep track of, especially if
+ you decide to work on another thing before your first change
+ is merged in.
+
+ GitHub has some pretty good
+ [general documentation](http://help.github.com/) on using
+ their site. They also have documentation on
+ [creating pull requests](http://help.github.com/send-pull-requests/).
+
+ In general, after pushing your topic branch up to your
+ repository on GitHub, you can switch to the branch in the
+ GitHub UI and click "Pull Request" towards the top of the page
+ in order to open a pull request.
+
+
+ 3. Update the related GitHub issue.
+
+ If there is a GitHub issue associated with the change you
+ submitted, then you should update the ticket to include the
+ location of your branch, along with any other commentary you
+ may wish to make.
+
+Testing
+=======
+
+Getting Started
+---------------
+
+Our puppet modules provide [`Gemfile`](./Gemfile)s which can tell a ruby
+package manager such as [bundler](http://bundler.io/) what Ruby packages,
+or Gems, are required to build, develop, and test this software.
+
+Please make sure you have [bundler installed](http://bundler.io/#getting-started)
+on your system, then use it to install all dependencies needed for this project,
+by running
+
+```shell
+% bundle install
+Fetching gem metadata from https://rubygems.org/........
+Fetching gem metadata from https://rubygems.org/..
+Using rake (10.1.0)
+Using builder (3.2.2)
+-- 8><-- many more --><8 --
+Using rspec-system-puppet (2.2.0)
+Using serverspec (0.6.3)
+Using rspec-system-serverspec (1.0.0)
+Using bundler (1.3.5)
+Your bundle is complete!
+Use `bundle show [gemname]` to see where a bundled gem is installed.
+```
+
+NOTE some systems may require you to run this command with sudo.
+
+If you already have those gems installed, make sure they are up-to-date:
+
+```shell
+% bundle update
+```
+
+With all dependencies in place and up-to-date we can now run the tests:
+
+```shell
+% rake spec
+```
+
+This will execute all the [rspec tests](http://rspec-puppet.com/) tests
+under [spec/defines](./spec/defines), [spec/classes](./spec/classes),
+and so on. rspec tests may have the same kind of dependencies as the
+module they are testing. While the module defines in its [Modulefile](./Modulefile),
+rspec tests define them in [.fixtures.yml](./fixtures.yml).
+
+Some puppet modules also come with [beaker](https://github.com/puppetlabs/beaker)
+tests. These tests spin up a virtual machine under
+[VirtualBox](https://www.virtualbox.org/)) with, controlling it with
+[Vagrant](http://www.vagrantup.com/) to actually simulate scripted test
+scenarios. In order to run these, you will need both of those tools
+installed on your system.
+
+You can run them by issuing the following command
+
+```shell
+% rake spec_clean
+% rspec spec/acceptance
+```
+
+This will now download a pre-fabricated image configured in the [default node-set](./spec/acceptance/nodesets/default.yml),
+install puppet, copy this module and install its dependencies per [spec/spec_helper_acceptance.rb](./spec/spec_helper_acceptance.rb)
+and then run all the tests under [spec/acceptance](./spec/acceptance).
+
+Writing Tests
+-------------
+
+XXX getting started writing tests.
+
+If you have commit access to the repository
+===========================================
+
+Even if you have commit access to the repository, you will still need to
+go through the process above, and have someone else review and merge
+in your changes. The rule is that all changes must be reviewed by a
+developer on the project (that did not write the code) to ensure that
+all changes go through a code review process.
+
+Having someone other than the author of the topic branch recorded as
+performing the merge is the record that they performed the code
+review.
+
+
+Additional Resources
+====================
+
+* [Getting additional help](http://puppetlabs.com/community/get-help)
+
+* [Writing tests](http://projects.puppetlabs.com/projects/puppet/wiki/Development_Writing_Tests)
+
+* [Patchwork](https://patchwork.puppetlabs.com)
+
+* [General GitHub documentation](http://help.github.com/)
+
+* [GitHub pull request documentation](http://help.github.com/send-pull-requests/)
+
--- /dev/null
+source ENV['GEM_SOURCE'] || 'https://rubygems.org'
+
+def location_for(place, fake_version = nil)
+ if place =~ /^(git[:@][^#]*)#(.*)/
+ [fake_version, { :git => $1, :branch => $2, :require => false }].compact
+ elsif place =~ /^file:\/\/(.*)/
+ ['>= 0', { :path => File.expand_path($1), :require => false }]
+ else
+ [place, { :require => false }]
+ end
+end
+
+group :development, :unit_tests do
+ gem 'rake', '~> 10.1.0', :require => false
+ gem 'rspec', '~> 3.1.0', :require => false
+ gem 'rspec-puppet', :require => false
+ gem 'puppetlabs_spec_helper', :require => false
+ gem 'puppet-lint', :require => false
+ gem 'pry', :require => false
+ gem 'simplecov', :require => false
+end
+
+beaker_version = ENV['BEAKER_VERSION']
+beaker_rspec_version = ENV['BEAKER_RSPEC_VERSION']
+group :system_tests do
+ if beaker_version
+ gem 'beaker', *location_for(beaker_version)
+ end
+ if beaker_rspec_version
+ gem 'beaker-rspec', *location_for(beaker_rspec_version)
+ else
+ gem 'beaker-rspec', :require => false
+ end
+ gem 'serverspec', :require => false
+end
+
+facterversion = ENV['GEM_FACTER_VERSION'] || ENV['FACTER_GEM_VERSION']
+if facterversion
+ gem 'facter', *location_for(facterversion)
+else
+ gem 'facter', :require => false
+end
+
+puppetversion = ENV['GEM_PUPPET_VERSION'] || ENV['PUPPET_GEM_VERSION']
+if puppetversion
+ gem 'puppet', *location_for(puppetversion)
+else
+ gem 'puppet', :require => false
+end
+
+# vim:ft=ruby
--- /dev/null
+Copyright (C) 2011 Puppet Labs Inc
+
+and some parts:
+
+Copyright (C) 2011 Krzysztof Wilczynski
+
+Puppet Labs can be contacted at: info@puppetlabs.com
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
--- /dev/null
+#stdlib
+
+####Table of Contents
+
+1. [Overview](#overview)
+2. [Module Description - What the module does and why it is useful](#module-description)
+3. [Setup - The basics of getting started with stdlib](#setup)
+4. [Usage - Configuration options and additional functionality](#usage)
+5. [Reference - An under-the-hood peek at what the module is doing and how](#reference)
+5. [Limitations - OS compatibility, etc.](#limitations)
+6. [Development - Guide for contributing to the module](#development)
+
+##Overview
+
+Adds a standard library of resources for Puppet modules.
+
+##Module Description
+
+This module provides a standard library of resources for the development of Puppet
+modules. Puppet modules make heavy use of this standard library. The stdlib module adds the following resources to Puppet:
+
+ * Stages
+ * Facts
+ * Functions
+ * Defined resource types
+ * Types
+ * Providers
+
+> *Note:* As of version 3.7, Puppet Enterprise no longer includes the stdlib module. If you're running Puppet Enterprise, you should install the most recent release of stdlib for compatibility with Puppet modules.
+
+##Setup
+
+Installing the stdlib module adds the functions, facts, and resources of this standard library to Puppet.
+
+##Usage
+
+After you've installed stdlib, all of its functions, facts, and resources are available for module use or development.
+
+If you want to use a standardized set of run stages for Puppet, `include stdlib` in your manifest.
+
+## Reference
+
+### Classes
+
+#### Public Classes
+
+* `stdlib`: Most of stdlib's features are automatically loaded by Puppet. To use standardized run stages in Puppet, declare this class in your manifest with `include stdlib`.
+
+ When declared, stdlib declares all other classes in the module. The only other class currently included in the module is `stdlib::stages`.
+
+ The stdlib class has no parameters.
+
+#### Private Classes
+
+* `stdlib::stages`: This class manages a standard set of run stages for Puppet. It is managed by the stdlib class and should not be declared independently.
+
+ The `stdlib::stages` class declares various run stages for deploying infrastructure, language runtimes, and application layers. The high level stages are (in order):
+
+ * setup
+ * main
+ * runtime
+ * setup_infra
+ * deploy_infra
+ * setup_app
+ * deploy_app
+ * deploy
+
+ Sample usage:
+
+ ```
+ node default {
+ include stdlib
+ class { java: stage => 'runtime' }
+ }
+ ```
+
+### Resources
+
+* `file_line`: This resource ensures that a given line, including whitespace at the beginning and end, is contained within a file. If the line is not contained in the given file, Puppet will add the line. Multiple resources can be declared to manage multiple lines in the same file. You can also use match to replace existing lines.
+
+ ```
+ file_line { 'sudo_rule':
+ path => '/etc/sudoers',
+ line => '%sudo ALL=(ALL) ALL',
+ }
+ file_line { 'sudo_rule_nopw':
+ path => '/etc/sudoers',
+ line => '%sudonopw ALL=(ALL) NOPASSWD: ALL',
+ }
+ ```
+
+ * `after`: Specify the line after which Puppet will add any new lines. (Existing lines are added in place.) Optional.
+ * `ensure`: Ensures whether the resource is present. Valid values are 'present', 'absent'.
+ * `line`: The line to be added to the file located by the `path` parameter.
+ * `match`: A regular expression to run against existing lines in the file; if a match is found, we replace that line rather than adding a new line. Optional.
+ * `multiple`: Determine if match can change multiple lines. Valid values are 'true', 'false'. Optional.
+ * `name`: An arbitrary name used as the identity of the resource.
+ * `path`: The file in which Puppet will ensure the line specified by the line parameter.
+
+### Functions
+
+#### `abs`
+
+Returns the absolute value of a number; for example, '-34.56' becomes '34.56'. Takes a single integer and float value as an argument. *Type*: rvalue
+
+#### `any2array`
+
+This converts any object to an array containing that object. Empty argument lists are converted to an empty array. Arrays are left untouched. Hashes are converted to arrays of alternating keys and values. *Type*: rvalue
+
+#### `base64`
+
+Converts a string to and from base64 encoding.
+Requires an action ('encode', 'decode') and either a plain or base64-encoded
+string. *Type*: rvalue
+
+#### `basename`
+
+Returns the `basename` of a path (optionally stripping an extension). For example:
+ * ('/path/to/a/file.ext') returns 'file.ext'
+ * ('relative/path/file.ext') returns 'file.ext'
+ * ('/path/to/a/file.ext', '.ext') returns 'file'
+
+ *Type*: rvalue
+
+#### `bool2num`
+
+Converts a boolean to a number. Converts values:
+ * 'false', 'f', '0', 'n', and 'no' to 0.
+ * 'true', 't', '1', 'y', and 'yes' to 1.
+ Requires a single boolean or string as an input. *Type*: rvalue
+
+#### `capitalize`
+
+Capitalizes the first letter of a string or array of strings.
+Requires either a single string or an array as an input. *Type*: rvalue
+
+#### `ceiling`
+
+Returns the smallest integer greater than or equal to the argument.
+Takes a single numeric value as an argument. *Type*: rvalue
+
+#### `chomp`
+
+Removes the record separator from the end of a string or an array of
+strings; for example, 'hello\n' becomes 'hello'. Requires a single string or array as an input. *Type*: rvalue
+
+#### `chop`
+
+Returns a new string with the last character removed. If the string ends with '\r\n', both characters are removed. Applying `chop` to an empty string returns an empty string. If you want to merely remove record separators, then you should use the `chomp` function. Requires a string or an array of strings as input. *Type*: rvalue
+
+#### `concat`
+
+Appends the contents of multiple arrays onto array 1. For example:
+ * `concat(['1','2','3'],'4')` results in: ['1','2','3','4'].
+ * `concat(['1','2','3'],'4',['5','6','7'])` results in: ['1','2','3','4','5','6','7'].
+
+#### `count`
+
+Takes an array as first argument and an optional second argument. Count the number of elements in array that matches second argument. If called with only an array, it counts the number of elements that are **not** nil/undef. *Type*: rvalue
+
+#### `defined_with_params`
+
+Takes a resource reference and an optional hash of attributes. Returns 'true' if a resource with the specified attributes has already been added to the catalog. Returns 'false' otherwise.
+
+ ```
+ user { 'dan':
+ ensure => present,
+ }
+
+ if ! defined_with_params(User[dan], {'ensure' => 'present' }) {
+ user { 'dan': ensure => present, }
+ }
+ ```
+
+ *Type*: rvalue
+
+#### `delete`
+
+Deletes all instances of a given element from an array, substring from a
+string, or key from a hash. For example, `delete(['a','b','c','b'], 'b')` returns ['a','c']; `delete('abracadabra', 'bra')` returns 'acada'. `delete({'a' => 1,'b' => 2,'c' => 3},['b','c'])` returns {'a'=> 1} *Type*: rvalue
+
+#### `delete_at`
+
+Deletes a determined indexed value from an array. For example, `delete_at(['a','b','c'], 1)` returns ['a','c']. *Type*: rvalue
+
+#### `delete_values`
+
+Deletes all instances of a given value from a hash. For example, `delete_values({'a'=>'A','b'=>'B','c'=>'C','B'=>'D'}, 'B')` returns {'a'=>'A','c'=>'C','B'=>'D'} *Type*: rvalue
+
+#### `delete_undef_values`
+
+Deletes all instances of the undef value from an array or hash. For example, `$hash = delete_undef_values({a=>'A', b=>'', c=>undef, d => false})` returns {a => 'A', b => '', d => false}. *Type*: rvalue
+
+#### `difference`
+
+Returns the difference between two arrays.
+The returned array is a copy of the original array, removing any items that
+also appear in the second array. For example, `difference(["a","b","c"],["b","c","d"])` returns ["a"].
+
+#### `dirname`
+
+Returns the `dirname` of a path. For example, `dirname('/path/to/a/file.ext')` returns '/path/to/a'.
+
+#### `downcase`
+
+Converts the case of a string or of all strings in an array to lowercase. *Type*: rvalue
+
+#### `empty`
+
+Returns 'true' if the variable is empty. *Type*: rvalue
+
+#### `ensure_packages`
+
+Takes a list of packages and only installs them if they don't already exist. It optionally takes a hash as a second parameter to be passed as the third argument to the `ensure_resource()` function. *Type*: statement
+
+#### `ensure_resource`
+
+Takes a resource type, title, and a list of attributes that describe a resource.
+
+ ```
+ user { 'dan':
+ ensure => present,
+ }
+ ```
+
+ This example only creates the resource if it does not already exist:
+
+ `ensure_resource('user', 'dan', {'ensure' => 'present' })`
+
+ If the resource already exists, but does not match the specified parameters, this function attempts to recreate the resource, leading to a duplicate resource definition error.
+
+ An array of resources can also be passed in, and each will be created with the type and parameters specified if it doesn't already exist.
+
+ `ensure_resource('user', ['dan','alex'], {'ensure' => 'present'})`
+
+ *Type*: statement
+
+#### `flatten`
+
+This function flattens any deeply nested arrays and returns a single flat array as a result. For example, `flatten(['a', ['b', ['c']]])` returns ['a','b','c']. *Type*: rvalue
+
+#### `floor`
+
+Returns the largest integer less than or equal to the argument.
+Takes a single numeric value as an argument. *Type*: rvalue
+
+#### `fqdn_rand_string`
+
+Generates a random alphanumeric string using an optionally-specified character set (default is alphanumeric), combining the `$fqdn` fact and an optional seed for repeatable randomness.
+
+*Usage:*
+```
+fqdn_rand_string(LENGTH, [CHARSET], [SEED])
+```
+*Examples:*
+```
+fqdn_rand_string(10)
+fqdn_rand_string(10, 'ABCDEF!@#$%^')
+fqdn_rand_string(10, '', 'custom seed')
+```
+
+*Type*: rvalue
+
+#### `fqdn_rotate`
+
+Rotates an array a random number of times based on a node's fqdn. *Type*: rvalue
+
+#### `get_module_path`
+
+Returns the absolute path of the specified module for the current environment.
+
+ `$module_path = get_module_path('stdlib')`
+
+ *Type*: rvalue
+
+#### `getparam`
+
+Takes a resource reference and the name of the parameter and
+returns the value of the resource's parameter. For example, the following code returns 'param_value'.
+
+ *Example:*
+
+ ```
+ define example_resource($param) {
+ }
+
+ example_resource { "example_resource_instance":
+ param => "param_value"
+ }
+
+ getparam(Example_resource["example_resource_instance"], "param")
+ ```
+
+ *Type*: rvalue
+
+#### `getvar`
+
+Lookup a variable in a remote namespace.
+
+ For example:
+
+ ```
+ $foo = getvar('site::data::foo')
+ # Equivalent to $foo = $site::data::foo
+ ```
+
+ This is useful if the namespace itself is stored in a string:
+
+ ```
+ $datalocation = 'site::data'
+ $bar = getvar("${datalocation}::bar")
+ # Equivalent to $bar = $site::data::bar
+ ```
+
+ *Type*: rvalue
+
+#### `grep`
+
+This function searches through an array and returns any elements that match the provided regular expression. For example, `grep(['aaa','bbb','ccc','aaaddd'], 'aaa')` returns ['aaa','aaaddd']. *Type*: rvalue
+
+#### `has_interface_with`
+
+Returns boolean based on kind and value:
+ * macaddress
+ * netmask
+ * ipaddress
+ * network
+
+ *Examples:*
+
+ ```
+ has_interface_with("macaddress", "x:x:x:x:x:x")
+ has_interface_with("ipaddress", "127.0.0.1") => true
+ ```
+
+ If no kind is given, then the presence of the interface is checked:
+
+ ```
+ has_interface_with("lo") => true
+ ```
+
+ *Type*: rvalue
+
+#### `has_ip_address`
+
+Returns true if the client has the requested IP address on some interface. This function iterates through the `interfaces` fact and checks the `ipaddress_IFACE` facts, performing a simple string comparison. *Type*: rvalue
+
+#### `has_ip_network`
+
+Returns true if the client has an IP address within the requested network. This function iterates through the 'interfaces' fact and checks the 'network_IFACE' facts, performing a simple string comparision. *Type*: rvalue
+
+#### `has_key`
+
+Determine if a hash has a certain key value.
+
+ *Example*:
+
+ ```
+ $my_hash = {'key_one' => 'value_one'}
+ if has_key($my_hash, 'key_two') {
+ notice('we will not reach here')
+ }
+ if has_key($my_hash, 'key_one') {
+ notice('this will be printed')
+ }
+ ```
+
+ *Type*: rvalue
+
+#### `hash`
+
+This function converts an array into a hash. For example, `hash(['a',1,'b',2,'c',3])` returns {'a'=>1,'b'=>2,'c'=>3}. *Type*: rvalue
+
+#### `intersection`
+
+This function returns an array an intersection of two. For example, `intersection(["a","b","c"],["b","c","d"])` returns ["b","c"].
+
+#### `is_array`
+
+Returns 'true' if the variable passed to this function is an array. *Type*: rvalue
+
+#### `is_bool`
+
+Returns 'true' if the variable passed to this function is a boolean. *Type*: rvalue
+
+#### `is_domain_name`
+
+Returns 'true' if the string passed to this function is a syntactically correct domain name. *Type*: rvalue
+
+#### `is_float`
+
+Returns 'true' if the variable passed to this function is a float. *Type*: rvalue
+
+#### `is_function_available`
+
+This function accepts a string as an argument and determines whether the Puppet runtime has access to a function by that name. It returns 'true' if the function exists, 'false' if not. *Type*: rvalue
+
+#### `is_hash`
+
+Returns 'true' if the variable passed to this function is a hash. *Type*: rvalue
+
+#### `is_integer`
+
+Returns 'true' if the variable returned to this string is an integer. *Type*: rvalue
+
+#### `is_ip_address`
+
+Returns 'true' if the string passed to this function is a valid IP address. *Type*: rvalue
+
+#### `is_mac_address`
+
+Returns 'true' if the string passed to this function is a valid MAC address. *Type*: rvalue
+
+#### `is_numeric`
+
+Returns 'true' if the variable passed to this function is a number. *Type*: rvalue
+
+#### `is_string`
+
+Returns 'true' if the variable passed to this function is a string. *Type*: rvalue
+
+#### `join`
+
+This function joins an array into a string using a separator. For example, `join(['a','b','c'], ",")` results in: "a,b,c". *Type*: rvalue
+
+#### `join_keys_to_values`
+
+This function joins each key of a hash to that key's corresponding value with a separator. Keys and values are cast to strings. The return value is an array in which each element is one joined key/value pair. For example, `join_keys_to_values({'a'=>1,'b'=>2}, " is ")` results in ["a is 1","b is 2"]. *Type*: rvalue
+
+#### `keys`
+
+Returns the keys of a hash as an array. *Type*: rvalue
+
+#### `loadyaml`
+
+Load a YAML file containing an array, string, or hash, and return the data in the corresponding native data type. For example:
+
+ ```
+ $myhash = loadyaml('/etc/puppet/data/myhash.yaml')
+ ```
+
+ *Type*: rvalue
+
+#### `lstrip`
+
+Strips leading spaces to the left of a string. *Type*: rvalue
+
+#### `max`
+
+Returns the highest value of all arguments. Requires at least one argument. *Type*: rvalue
+
+#### `member`
+
+This function determines if a variable is a member of an array. The variable can be either a string, array, or fixnum. For example, `member(['a','b'], 'b')` and `member(['a','b','c'], ['b','c'])` return 'true', while `member(['a','b'], 'c')` and `member(['a','b','c'], ['c','d'])` return 'false'. *Type*: rvalue
+
+#### `merge`
+
+Merges two or more hashes together and returns the resulting hash.
+
+ *Example*:
+
+ ```
+ $hash1 = {'one' => 1, 'two' => 2}
+ $hash2 = {'two' => 'dos', 'three' => 'tres'}
+ $merged_hash = merge($hash1, $hash2)
+ # The resulting hash is equivalent to:
+ # $merged_hash = {'one' => 1, 'two' => 'dos', 'three' => 'tres'}
+ ```
+
+ When there is a duplicate key, the key in the rightmost hash "wins." *Type*: rvalue
+
+#### `min`
+
+Returns the lowest value of all arguments. Requires at least one argument. *Type*: rvalue
+
+#### `num2bool`
+
+This function converts a number or a string representation of a number into a true boolean. Zero or anything non-numeric becomes 'false'. Numbers greater than 0 become 'true'. *Type*: rvalue
+
+#### `parsejson`
+
+This function accepts JSON as a string and converts into the correct Puppet structure. *Type*: rvalue
+
+#### `parseyaml`
+
+This function accepts YAML as a string and converts it into the correct Puppet structure. *Type*: rvalue
+
+#### `pick`
+
+From a list of values, returns the first value that is not undefined or an empty string. Takes any number of arguments, and raises an error if all values are undefined or empty.
+
+ ```
+ $real_jenkins_version = pick($::jenkins_version, '1.449')
+ ```
+
+ *Type*: rvalue
+
+#### `prefix`
+
+This function applies a prefix to all elements in an array or to the keys in a hash. For example, `prefix(['a','b','c'], 'p')` returns ['pa','pb','pc'], and `prefix({'a'=>'b','b'=>'c','c'=>'d'}, 'p')` returns {'pa'=>'b','pb'=>'c','pc'=>'d'}. *Type*: rvalue
+
+
+#### `assert_private`
+
+This function sets the current class or definition as private.
+Calling the class or definition from outside the current module will fail. For example, `assert_private()` called in class `foo::bar` outputs the following message if class is called from outside module `foo`:
+
+ ```
+ Class foo::bar is private
+ ```
+
+ You can specify the error message you want to use:
+
+ ```
+ assert_private("You're not supposed to do that!")
+ ```
+
+ *Type*: statement
+
+#### `pw_hash`
+
+Hashes a password using the crypt function. Provides a hash usable on most POSIX systems.
+
+The first argument to this function is the password to hash. If it is undef or an empty string, this function returns undef.
+
+The second argument to this function is which type of hash to use. It will be converted into the appropriate crypt(3) hash specifier. Valid hash types are:
+
+|Hash type |Specifier|
+|---------------------|---------|
+|MD5 |1 |
+|SHA-256 |5 |
+|SHA-512 (recommended)|6 |
+
+The third argument to this function is the salt to use.
+
+Note: this uses the Puppet Master's implementation of crypt(3). If your environment contains several different operating systems, ensure that they are compatible before using this function.
+
+#### `range`
+
+When given range in the form of '(start, stop)', `range` extrapolates a range as an array. For example, `range("0", "9")` returns [0,1,2,3,4,5,6,7,8,9]. Zero-padded strings are converted to integers automatically, so `range("00", "09")` returns [0,1,2,3,4,5,6,7,8,9].
+
+ Non-integer strings are accepted; `range("a", "c")` returns ["a","b","c"], and `range("host01", "host10")` returns ["host01", "host02", ..., "host09", "host10"].
+
+ Passing a third argument will cause the generated range to step by that interval, e.g. `range("0", "9", "2")` returns ["0","2","4","6","8"]
+
+ *Type*: rvalue
+
+#### `reject`
+
+This function searches through an array and rejects all elements that match the provided regular expression. For example, `reject(['aaa','bbb','ccc','aaaddd'], 'aaa')` returns ['bbb','ccc']. *Type*: rvalue
+
+#### `reverse`
+
+Reverses the order of a string or array. *Type*: rvalue
+
+#### `rstrip`
+
+Strips leading spaces to the right of the string.*Type*: rvalue
+
+#### `shuffle`
+
+Randomizes the order of a string or array elements. *Type*: rvalue
+
+#### `size`
+
+Returns the number of elements in a string or array. *Type*: rvalue
+
+#### `sort`
+
+Sorts strings and arrays lexically. *Type*: rvalue
+
+#### `squeeze`
+
+Returns a new string where runs of the same character that occur in this set are replaced by a single character. *Type*: rvalue
+
+#### `str2bool`
+
+This converts a string to a boolean. This attempts to convert strings that contain values such as '1', 't', 'y', and 'yes' to 'true' and strings that contain values such as '0', 'f', 'n', and 'no' to 'false'. *Type*: rvalue
+
+#### `str2saltedsha512`
+
+This converts a string to a salted-SHA512 password hash, used for OS X versions >= 10.7. Given any string, this function returns a hex version of a salted-SHA512 password hash, which can be inserted into your Puppet
+manifests as a valid password attribute. *Type*: rvalue
+
+#### `strftime`
+
+This function returns formatted time. For example, `strftime("%s")` returns the time since epoch, and `strftime("%Y=%m-%d")` returns the date. *Type*: rvalue
+
+ *Format:*
+
+ * `%a`: The abbreviated weekday name ('Sun')
+ * `%A`: The full weekday name ('Sunday')
+ * `%b`: The abbreviated month name ('Jan')
+ * `%B`: The full month name ('January')
+ * `%c`: The preferred local date and time representation
+ * `%C`: Century (20 in 2009)
+ * `%d`: Day of the month (01..31)
+ * `%D`: Date (%m/%d/%y)
+ * `%e`: Day of the month, blank-padded ( 1..31)
+ * `%F`: Equivalent to %Y-%m-%d (the ISO 8601 date format)
+ * `%h`: Equivalent to %b
+ * `%H`: Hour of the day, 24-hour clock (00..23)
+ * `%I`: Hour of the day, 12-hour clock (01..12)
+ * `%j`: Day of the year (001..366)
+ * `%k`: Hour, 24-hour clock, blank-padded ( 0..23)
+ * `%l`: Hour, 12-hour clock, blank-padded ( 0..12)
+ * `%L`: Millisecond of the second (000..999)
+ * `%m`: Month of the year (01..12)
+ * `%M`: Minute of the hour (00..59)
+ * `%n`: Newline (\n)
+ * `%N`: Fractional seconds digits, default is 9 digits (nanosecond)
+ * `%3N`: Millisecond (3 digits)
+ * `%6N`: Microsecond (6 digits)
+ * `%9N`: Nanosecond (9 digits)
+ * `%p`: Meridian indicator ('AM' or 'PM')
+ * `%P`: Meridian indicator ('am' or 'pm')
+ * `%r`: Time, 12-hour (same as %I:%M:%S %p)
+ * `%R`: Time, 24-hour (%H:%M)
+ * `%s`: Number of seconds since 1970-01-01 00:00:00 UTC.
+ * `%S`: Second of the minute (00..60)
+ * `%t`: Tab character ( )
+ * `%T`: Time, 24-hour (%H:%M:%S)
+ * `%u`: Day of the week as a decimal, Monday being 1. (1..7)
+ * `%U`: Week number of the current year, starting with the first Sunday as the first day of the first week (00..53)
+ * `%v`: VMS date (%e-%b-%Y)
+ * `%V`: Week number of year according to ISO 8601 (01..53)
+ * `%W`: Week number of the current year, starting with the first Monday as the first day of the first week (00..53)
+ * `%w`: Day of the week (Sunday is 0, 0..6)
+ * `%x`: Preferred representation for the date alone, no time
+ * `%X`: Preferred representation for the time alone, no date
+ * `%y`: Year without a century (00..99)
+ * `%Y`: Year with century
+ * `%z`: Time zone as hour offset from UTC (e.g. +0900)
+ * `%Z`: Time zone name
+ * `%%`: Literal '%' character
+
+#### `strip`
+
+This function removes leading and trailing whitespace from a string or from every string inside an array. For example, `strip(" aaa ")` results in "aaa". *Type*: rvalue
+
+#### `suffix`
+
+This function applies a suffix to all elements in an array. For example, `suffix(['a','b','c'], 'p')` returns ['ap','bp','cp']. *Type*: rvalue
+
+#### `swapcase`
+
+This function swaps the existing case of a string. For example, `swapcase("aBcD")` results in "AbCd". *Type*: rvalue
+
+#### `time`
+
+This function returns the current time since epoch as an integer. For example, `time()` returns something like '1311972653'. *Type*: rvalue
+
+#### `to_bytes`
+
+Converts the argument into bytes, for example 4 kB becomes 4096.
+Takes a single string value as an argument. *Type*: rvalue
+
+#### `type3x`
+
+Returns a string description of the type when passed a value. Type can be a string, array, hash, float, integer, or boolean. This function will be removed when puppet 3 support is dropped and the new type system may be used. *Type*: rvalue
+
+#### `type_of`
+
+Returns the literal type when passed a value. Requires the new
+ parser. Useful for comparison of types with `<=` such as in `if
+ type_of($some_value) <= Array[String] { ... }` (which is equivalent to `if
+ $some_value =~ Array[String] { ... }`) *Type*: rvalue
+
+#### `union`
+
+This function returns a union of two arrays. For example, `union(["a","b","c"],["b","c","d"])` returns ["a","b","c","d"].
+
+#### `unique`
+
+This function removes duplicates from strings and arrays. For example, `unique("aabbcc")` returns 'abc'.
+
+You can also use this with arrays. For example, `unique(["a","a","b","b","c","c"])` returns ["a","b","c"]. *Type*: rvalue
+
+#### `upcase`
+
+Converts an object, array or hash of objects that respond to upcase to uppercase. For example, `upcase("abcd")` returns 'ABCD'. *Type*: rvalue
+
+#### `uriescape`
+
+Urlencodes a string or array of strings. Requires either a single string or an array as an input. *Type*: rvalue
+
+#### `validate_absolute_path`
+
+Validate the string represents an absolute path in the filesystem. This function works for Windows and Unix style paths.
+
+ The following values will pass:
+
+ ```
+ $my_path = 'C:/Program Files (x86)/Puppet Labs/Puppet'
+ validate_absolute_path($my_path)
+ $my_path2 = '/var/lib/puppet'
+ validate_absolute_path($my_path2)
+ $my_path3 = ['C:/Program Files (x86)/Puppet Labs/Puppet','C:/Program Files/Puppet Labs/Puppet']
+ validate_absolute_path($my_path3)
+ $my_path4 = ['/var/lib/puppet','/usr/share/puppet']
+ validate_absolute_path($my_path4)
+ ```
+
+ The following values will fail, causing compilation to abort:
+
+ ```
+ validate_absolute_path(true)
+ validate_absolute_path('../var/lib/puppet')
+ validate_absolute_path('var/lib/puppet')
+ validate_absolute_path([ 'var/lib/puppet', '/var/foo' ])
+ validate_absolute_path([ '/var/lib/puppet', 'var/foo' ])
+ $undefined = undef
+ validate_absolute_path($undefined)
+ ```
+
+ *Type*: statement
+
+#### `validate_array`
+
+Validate that all passed values are array data structures. Abort catalog compilation if any value fails this check.
+
+ The following values will pass:
+
+ ```
+ $my_array = [ 'one', 'two' ]
+ validate_array($my_array)
+ ```
+
+ The following values will fail, causing compilation to abort:
+
+ ```
+ validate_array(true)
+ validate_array('some_string')
+ $undefined = undef
+ validate_array($undefined)
+ ```
+
+ *Type*: statement
+
+#### `validate_augeas`
+
+Performs validation of a string using an Augeas lens.
+The first argument of this function should be the string to test, and the second argument should be the name of the Augeas lens to use. If Augeas fails to parse the string with the lens, the compilation aborts with a parse error.
+
+ A third optional argument lists paths which should **not** be found in the file. The `$file` variable points to the location of the temporary file being tested in the Augeas tree.
+
+ For example, to make sure your passwd content never contains user `foo`:
+
+ ```
+ validate_augeas($passwdcontent, 'Passwd.lns', ['$file/foo'])
+ ```
+
+ To ensure that no users use the '/bin/barsh' shell:
+
+ ```
+ validate_augeas($passwdcontent, 'Passwd.lns', ['$file/*[shell="/bin/barsh"]']
+ ```
+
+ You can pass a fourth argument as the error message raised and shown to the user:
+
+ ```
+ validate_augeas($sudoerscontent, 'Sudoers.lns', [], 'Failed to validate sudoers content with Augeas')
+ ```
+
+ *Type*: statement
+
+#### `validate_bool`
+
+Validate that all passed values are either true or false. Abort catalog compilation if any value fails this check.
+
+ The following values will pass:
+
+ ```
+ $iamtrue = true
+ validate_bool(true)
+ validate_bool(true, true, false, $iamtrue)
+ ```
+
+ The following values will fail, causing compilation to abort:
+
+ ```
+ $some_array = [ true ]
+ validate_bool("false")
+ validate_bool("true")
+ validate_bool($some_array)
+ ```
+
+ *Type*: statement
+
+#### `validate_cmd`
+
+Performs validation of a string with an external command. The first argument of this function should be a string to test, and the second argument should be a path to a test command taking a % as a placeholder for the file path (will default to the end of the command if no % placeholder given). If the command, launched against a tempfile containing the passed string, returns a non-null value, compilation will abort with a parse error.
+
+If a third argument is specified, this will be the error message raised and seen by the user.
+
+ ```
+ # Defaults to end of path
+ validate_cmd($sudoerscontent, '/usr/sbin/visudo -c -f', 'Visudo failed to validate sudoers content')
+ ```
+ ```
+ # % as file location
+ validate_cmd($haproxycontent, '/usr/sbin/haproxy -f % -c', 'Haproxy failed to validate config content')
+ ```
+
+ *Type*: statement
+
+#### `validate_hash`
+
+Validates that all passed values are hash data structures. Abort catalog compilation if any value fails this check.
+
+ The following values will pass:
+
+ ```
+ $my_hash = { 'one' => 'two' }
+ validate_hash($my_hash)
+ ```
+
+ The following values will fail, causing compilation to abort:
+
+ ```
+ validate_hash(true)
+ validate_hash('some_string')
+ $undefined = undef
+ validate_hash($undefined)
+ ```
+
+ *Type*: statement
+
+#### `validate_integer`
+
+Validate that the first argument is an integer (or an array of integers). Abort catalog compilation if any of the checks fail.
+
+ The second argument is optional and passes a maximum. (All elements of) the first argument has to be less or equal to this max.
+
+ The third argument is optional and passes a minimum. (All elements of) the first argument has to be greater or equal to this min.
+ If, and only if, a minimum is given, the second argument may be an empty string or undef, which will be handled to just check
+ if (all elements of) the first argument are greater or equal to the given minimum.
+
+ It will fail if the first argument is not an integer or array of integers, and if arg 2 and arg 3 are not convertable to an integer.
+
+ The following values will pass:
+
+ ```
+ validate_integer(1)
+ validate_integer(1, 2)
+ validate_integer(1, 1)
+ validate_integer(1, 2, 0)
+ validate_integer(2, 2, 2)
+ validate_integer(2, '', 0)
+ validate_integer(2, undef, 0)
+ $foo = undef
+ validate_integer(2, $foo, 0)
+ validate_integer([1,2,3,4,5], 6)
+ validate_integer([1,2,3,4,5], 6, 0)
+ ```
+
+ * Plus all of the above, but any combination of values passed as strings ('1' or "1").
+ * Plus all of the above, but with (correct) combinations of negative integer values.
+
+ The following values will fail, causing compilation to abort:
+
+ ```
+ validate_integer(true)
+ validate_integer(false)
+ validate_integer(7.0)
+ validate_integer({ 1 => 2 })
+ $foo = undef
+ validate_integer($foo)
+ validate_integer($foobaridontexist)
+
+ validate_integer(1, 0)
+ validate_integer(1, true)
+ validate_integer(1, '')
+ validate_integer(1, undef)
+ validate_integer(1, , 0)
+ validate_integer(1, 2, 3)
+ validate_integer(1, 3, 2)
+ validate_integer(1, 3, true)
+ ```
+
+ * Plus all of the above, but any combination of values passed as strings ('false' or "false").
+ * Plus all of the above, but with incorrect combinations of negative integer values.
+ * Plus all of the above, but with non-integer crap in arrays or maximum / minimum argument.
+
+ *Type*: statement
+
+#### `validate_numeric`
+
+Validate that the first argument is a numeric value (or an array of numeric values). Abort catalog compilation if any of the checks fail.
+
+ The second argument is optional and passes a maximum. (All elements of) the first argument has to be less or equal to this max.
+
+ The third argument is optional and passes a minimum. (All elements of) the first argument has to be greater or equal to this min.
+ If, and only if, a minimum is given, the second argument may be an empty string or undef, which will be handled to just check
+ if (all elements of) the first argument are greater or equal to the given minimum.
+
+ It will fail if the first argument is not a numeric (Integer or Float) or array of numerics, and if arg 2 and arg 3 are not convertable to a numeric.
+
+ For passing and failing usage, see `validate_integer()`. It is all the same for validate_numeric, yet now floating point values are allowed, too.
+
+ *Type*: statement
+
+#### `validate_re`
+
+Performs simple validation of a string against one or more regular expressions. The first argument of this function should be the string to
+test, and the second argument should be a stringified regular expression
+(without the // delimiters) or an array of regular expressions. If none
+of the regular expressions match the string passed in, compilation aborts with a parse error.
+
+ You can pass a third argument as the error message raised and shown to the user.
+
+ The following strings validate against the regular expressions:
+
+ ```
+ validate_re('one', '^one$')
+ validate_re('one', [ '^one', '^two' ])
+ ```
+
+ The following string fails to validate, causing compilation to abort:
+
+ ```
+ validate_re('one', [ '^two', '^three' ])
+ ```
+
+ To set the error message:
+
+ ```
+ validate_re($::puppetversion, '^2.7', 'The $puppetversion fact value does not match 2.7')
+ ```
+
+ *Type*: statement
+
+#### `validate_slength`
+
+Validates that the first argument is a string (or an array of strings), and is less than or equal to the length of the second argument. It fails if the first argument is not a string or array of strings, or if arg 2 is not convertable to a number.
+
+ The following values pass:
+
+ ```
+ validate_slength("discombobulate",17)
+ validate_slength(["discombobulate","moo"],17)
+ ```
+
+ The following values fail:
+
+ ```
+ validate_slength("discombobulate",1)
+ validate_slength(["discombobulate","thermometer"],5)
+ ```
+
+ *Type*: statement
+
+#### `validate_string`
+
+Validates that all passed values are string data structures. Aborts catalog compilation if any value fails this check.
+
+ The following values pass:
+
+ ```
+ $my_string = "one two"
+ validate_string($my_string, 'three')
+ ```
+
+ The following values fail, causing compilation to abort:
+
+ ```
+ validate_string(true)
+ validate_string([ 'some', 'array' ])
+ $undefined = undef
+ validate_string($undefined)
+ ```
+
+ *Type*: statement
+
+#### `values`
+
+When given a hash, this function returns the values of that hash.
+
+ *Examples:*
+
+ ```
+ $hash = {
+ 'a' => 1,
+ 'b' => 2,
+ 'c' => 3,
+ }
+ values($hash)
+ ```
+
+ The example above returns [1,2,3].
+
+ *Type*: rvalue
+
+#### `values_at`
+
+Finds value inside an array based on location. The first argument is the array you want to analyze, and the second element can be a combination of:
+
+ * A single numeric index
+ * A range in the form of 'start-stop' (eg. 4-9)
+ * An array combining the above
+
+ For example, `values_at(['a','b','c'], 2)` returns ['c']; `values_at(['a','b','c'], ["0-1"])` returns ['a','b']; and `values_at(['a','b','c','d','e'], [0, "2-3"])` returns ['a','c','d'].
+
+ *Type*: rvalue
+
+#### `zip`
+
+Takes one element from first array and merges corresponding elements from second array. This generates a sequence of n-element arrays, where n is one more than the count of arguments. For example, `zip(['1','2','3'],['4','5','6'])` results in ["1", "4"], ["2", "5"], ["3", "6"]. *Type*: rvalue
+
+##Limitations
+
+As of Puppet Enterprise version 3.7, the stdlib module is no longer included in PE. PE users should install the most recent release of stdlib for compatibility with Puppet modules.
+
+###Version Compatibility
+
+Versions | Puppet 2.6 | Puppet 2.7 | Puppet 3.x | Puppet 4.x |
+:---------------|:-----:|:---:|:---:|:----:
+**stdlib 2.x** | **yes** | **yes** | no | no
+**stdlib 3.x** | no | **yes** | **yes** | no
+**stdlib 4.x** | no | **yes** | **yes** | no
+**stdlib 5.x** | no | no | **yes** | **yes**
+
+**stdlib 5.x**: When released, stdlib 5.x will drop support for Puppet 2.7.x. Please see [this discussion](https://github.com/puppetlabs/puppetlabs-stdlib/pull/176#issuecomment-30251414).
+
+##Development
+
+Puppet Labs modules on the Puppet Forge are open projects, and community contributions are essential for keeping them great. We can’t access the huge number of platforms and myriad of hardware, software, and deployment configurations that Puppet is intended to serve.
+
+We want to keep it as easy as possible to contribute changes so that our modules work in your environment. There are a few guidelines that we need contributors to follow so that we can have a chance of keeping on top of things.
+
+You can read the complete module contribution guide on the [Puppet Labs wiki](http://projects.puppetlabs.com/projects/module-site/wiki/Module_contributing).
+
+To report or research a bug with any part of this module, please go to
+[http://tickets.puppetlabs.com/browse/PUP](http://tickets.puppetlabs.com/browse/PUP).
+
+##Contributors
+
+The list of contributors can be found at: https://github.com/puppetlabs/puppetlabs-stdlib/graphs/contributors
+
+
+
+
--- /dev/null
+Puppet Specific Facts
+=====================
+
+Facter is meant to stand alone and apart from Puppet. However, Facter often
+runs inside Puppet and all custom facts included in the stdlib module will
+almost always be evaluated in the context of Puppet and Facter working
+together.
+
+Still, we don't want to write custom facts that blow up in the users face if
+Puppet is not loaded in memory. This is often the case if the user runs
+`facter` without also supplying the `--puppet` flag.
+
+Ah! But Jeff, the custom fact won't be in the `$LOAD_PATH` unless the user
+supplies `--facter`! You might say...
+
+Not (always) true I say! If the user happens to have a CWD of
+`<modulepath>/stdlib/lib` then the facts will automatically be evaluated and
+blow up.
+
+In any event, it's pretty easy to write a fact that has no value if Puppet is
+not loaded. Simply do it like this:
+
+ Facter.add(:node_vardir) do
+ setcode do
+ # This will be nil if Puppet is not available.
+ Facter::Util::PuppetSettings.with_puppet do
+ Puppet[:vardir]
+ end
+ end
+ end
+
+The `Facter::Util::PuppetSettings.with_puppet` method accepts a block and
+yields to it only if the Puppet library is loaded. If the Puppet library is
+not loaded, then the method silently returns `nil` which Facter interprets as
+an undefined fact value. The net effect is that the fact won't be set.
--- /dev/null
+NOTE
+====
+
+This project's specs depend on puppet core, and thus they require the
+`puppetlabs_spec_helper` project. For more information please see the README
+in that project, which can be found here: [puppetlabs spec
+helper](https://github.com/puppetlabs/puppetlabs_spec_helper)
--- /dev/null
+# Contributing to this module #
+
+ * Work in a topic branch
+ * Submit a github pull request
+ * Address any comments / feeback
+ * Merge into master using --no-ff
+
+# Releasing this module #
+
+ * This module adheres to http://semver.org/
+ * Look for API breaking changes using git diff vX.Y.Z..master
+ * If no API breaking changes, the minor version may be bumped.
+ * If there are API breaking changes, the major version must be bumped.
+ * If there are only small minor changes, the patch version may be bumped.
+ * Update the CHANGELOG
+ * Update the Modulefile
+ * Commit these changes with a message along the lines of "Update CHANGELOG and
+ Modulefile for release"
+ * Create an annotated tag with git tag -a vX.Y.Z -m 'version X.Y.Z' (NOTE the
+ leading v as per semver.org)
+ * Push the tag with git push origin --tags
+ * Build a new package with puppet-module or the rake build task if it exists
+ * Publish the new package to the forge
+ * Bonus points for an announcement to puppet-users.
--- /dev/null
+require 'rubygems'
+require 'puppetlabs_spec_helper/rake_tasks'
+require 'puppet-lint/tasks/puppet-lint'
+PuppetLint.configuration.send('disable_80chars')
+PuppetLint.configuration.ignore_paths = ["spec/**/*.pp", "pkg/**/*.pp"]
+
+desc "Validate manifests, templates, and ruby files in lib."
+task :validate do
+ Dir['manifests/**/*.pp'].each do |manifest|
+ sh "puppet parser validate --noop #{manifest}"
+ end
+ Dir['lib/**/*.rb'].each do |lib_file|
+ sh "ruby -c #{lib_file}"
+ end
+ Dir['templates/**/*.erb'].each do |template|
+ sh "erb -P -x -T '-' #{template} | ruby -c"
+ end
+end
--- /dev/null
+{
+ "CHANGELOG.md": "0df10b918eaaa55394d222a36089aedc",
+ "CONTRIBUTING.md": "e2b8e8e433fc76b3798b7fe435f49375",
+ "Gemfile": "f5c444df2b7f648ce49b6a24bb1c338d",
+ "LICENSE": "38a048b9d82e713d4e1b2573e370a756",
+ "README.markdown": "e09856fda53506497ddde02ce6f1e2cb",
+ "README_DEVELOPER.markdown": "220a8b28521b5c5d2ea87c4ddb511165",
+ "README_SPECS.markdown": "82bb4c6abbb711f40778b162ec0070c1",
+ "RELEASE_PROCESS.markdown": "94b92bc99ac4106ba1a74d5c04e520f9",
+ "Rakefile": "dfa334598bfd087adf11533a72d71106",
+ "lib/facter/facter_dot_d.rb": "15c1ec06d198c8e7cf2339ca34211b7a",
+ "lib/facter/pe_version.rb": "4a9353952963b011759f3e6652a10da5",
+ "lib/facter/puppet_vardir.rb": "c7ddc97e8a84ded3dd93baa5b9b3283d",
+ "lib/facter/root_home.rb": "d9c8276acdceb7340d95f60c36dcdcc5",
+ "lib/facter/util/puppet_settings.rb": "9f1d2593d0ae56bfca89d4b9266aeee1",
+ "lib/puppet/functions/type_of.rb": "71e19f89e167c45ec691ea6c7d319625",
+ "lib/puppet/parser/functions/abs.rb": "32161bd0435fdfc2aec2fc559d2b454b",
+ "lib/puppet/parser/functions/any2array.rb": "a81e71d6b67a551d38770ba9a1948a75",
+ "lib/puppet/parser/functions/assert_private.rb": "1365284f9e474ecec24cfe43ee8e7cf4",
+ "lib/puppet/parser/functions/base64.rb": "ae25adf92295df67ebd9edfabc9ecdd6",
+ "lib/puppet/parser/functions/basename.rb": "c61952b3f68fd86408c84fca2c3febb1",
+ "lib/puppet/parser/functions/bool2num.rb": "f953f5fc094c2ae3908a72d8840ba291",
+ "lib/puppet/parser/functions/bool2str.rb": "34497af8db94754542b9d4cfacc8a27f",
+ "lib/puppet/parser/functions/camelcase.rb": "71c67b71eac4b7f46a0dd22cb915d2e6",
+ "lib/puppet/parser/functions/capitalize.rb": "da131748a9d32da9eb0b6438e39377eb",
+ "lib/puppet/parser/functions/ceiling.rb": "dfa9b1c75ce89344026b3b5aed2d190f",
+ "lib/puppet/parser/functions/chomp.rb": "2b7dc42f9967edd34cfa0ba9a97229ca",
+ "lib/puppet/parser/functions/chop.rb": "0ec76f54afd94201f35785dfeb2092b5",
+ "lib/puppet/parser/functions/concat.rb": "2a12f95e94669129827ee2f2a26349c3",
+ "lib/puppet/parser/functions/count.rb": "9eb74eccd93e2b3c87fd5ea14e329eba",
+ "lib/puppet/parser/functions/deep_merge.rb": "d83696855578fb81b64b9e92b9c7cc7c",
+ "lib/puppet/parser/functions/defined_with_params.rb": "ffab4433d03f32b551f2ea024a2948fc",
+ "lib/puppet/parser/functions/delete.rb": "cec92c5de6d748c8dc93ca7d25ac1c68",
+ "lib/puppet/parser/functions/delete_at.rb": "6bc24b79390d463d8be95396c963381a",
+ "lib/puppet/parser/functions/delete_undef_values.rb": "b32d4a3925753b2eb2c318cbd7f14404",
+ "lib/puppet/parser/functions/delete_values.rb": "39b147f7d369bb5f809044b6341954a2",
+ "lib/puppet/parser/functions/difference.rb": "e31b95fbaf974cf853a510177368bfb9",
+ "lib/puppet/parser/functions/dirname.rb": "8a5579f9a9a13fd737ba65eccf8e6d5a",
+ "lib/puppet/parser/functions/downcase.rb": "73121616d73339cf8dd10e0de61a6c50",
+ "lib/puppet/parser/functions/empty.rb": "0b6ca9d0550a39c1ca50fc3d1ecbc98c",
+ "lib/puppet/parser/functions/ensure_packages.rb": "fbed5c0c9bf82b7746e01f15f89d184f",
+ "lib/puppet/parser/functions/ensure_resource.rb": "de703fe63392b939fc2b4392975263de",
+ "lib/puppet/parser/functions/flatten.rb": "25777b76f9719162a8bab640e5595b7a",
+ "lib/puppet/parser/functions/floor.rb": "42cad4c689231a51526c55a6f0985d1f",
+ "lib/puppet/parser/functions/fqdn_rand_string.rb": "375a7436960805b13ae34e2f970da443",
+ "lib/puppet/parser/functions/fqdn_rotate.rb": "2485c2eab774a8b1f52de9c17d4b0833",
+ "lib/puppet/parser/functions/get_module_path.rb": "d4bf50da25c0b98d26b75354fa1bcc45",
+ "lib/puppet/parser/functions/getparam.rb": "4dd7a0e35f4a3780dcfc9b19b4e0006e",
+ "lib/puppet/parser/functions/getvar.rb": "ab01ce68140bbdd84162a519a14ece3b",
+ "lib/puppet/parser/functions/grep.rb": "5682995af458b05f3b53dd794c4bf896",
+ "lib/puppet/parser/functions/has_interface_with.rb": "ee3a1d6193951939b492a69ef170faac",
+ "lib/puppet/parser/functions/has_ip_address.rb": "ee207f47906455a5aa49c4fb219dd325",
+ "lib/puppet/parser/functions/has_ip_network.rb": "b4d726c8b2a0afac81ced8a3a28aa731",
+ "lib/puppet/parser/functions/has_key.rb": "7cd9728c38f0b0065f832dabd62b0e7e",
+ "lib/puppet/parser/functions/hash.rb": "9d072527dfc7354b69292e9302906530",
+ "lib/puppet/parser/functions/intersection.rb": "924ac4aceec7b896952166a7ec08fdb1",
+ "lib/puppet/parser/functions/is_array.rb": "875ca4356cb0d7a10606fb146b4a3d11",
+ "lib/puppet/parser/functions/is_bool.rb": "e693b7c4b5366cff1380b6e0c7dd7b11",
+ "lib/puppet/parser/functions/is_domain_name.rb": "6ca1f2708add756a6803b29d593d5830",
+ "lib/puppet/parser/functions/is_float.rb": "10e0d3ecf75fac15e415aee79acf70dc",
+ "lib/puppet/parser/functions/is_function_available.rb": "628428bbcd9313ce09783d9484330e09",
+ "lib/puppet/parser/functions/is_hash.rb": "8c7d9a05084dab0389d1b779c8a05b1a",
+ "lib/puppet/parser/functions/is_integer.rb": "c665be82686aa4729959bb42c66a7510",
+ "lib/puppet/parser/functions/is_ip_address.rb": "a714a736c1560e8739aaacd9030cca00",
+ "lib/puppet/parser/functions/is_mac_address.rb": "288bd4b38d4df42a83681f13e7eaaee0",
+ "lib/puppet/parser/functions/is_numeric.rb": "93ddc9d4c0834a5e5e0562d7b3cdce91",
+ "lib/puppet/parser/functions/is_string.rb": "2bd9a652bbb2668323eee6c57729ff64",
+ "lib/puppet/parser/functions/join.rb": "a285a05c015ae278608f6454aef211ea",
+ "lib/puppet/parser/functions/join_keys_to_values.rb": "f29da49531228f6ca5b3aa0df00a14c2",
+ "lib/puppet/parser/functions/keys.rb": "eb6ac815ea14fbf423580ed903ef7bad",
+ "lib/puppet/parser/functions/loadyaml.rb": "2b912f257aa078e376d3b3f6a86c2a00",
+ "lib/puppet/parser/functions/lstrip.rb": "20a9b1fa077c16f34e0ef5448b895698",
+ "lib/puppet/parser/functions/max.rb": "f652fd0b46ef7d2fbdb42b141f8fdd1d",
+ "lib/puppet/parser/functions/member.rb": "3c5375ebf3e2dafa84903009f0f1f47c",
+ "lib/puppet/parser/functions/merge.rb": "f3dcc5c83440cdda2036cce69b61a14b",
+ "lib/puppet/parser/functions/min.rb": "0d2a1b7e735ab251c5469e735fa3f4c6",
+ "lib/puppet/parser/functions/num2bool.rb": "605c12fa518c87ed2c66ae153e0686ce",
+ "lib/puppet/parser/functions/parsejson.rb": "e7f968c34928107b84cd0860daf50ab1",
+ "lib/puppet/parser/functions/parseyaml.rb": "00f10ec1e2b050e23d80c256061ebdd7",
+ "lib/puppet/parser/functions/pick.rb": "bf01f13bbfe2318e7f6a302ac7c4433f",
+ "lib/puppet/parser/functions/pick_default.rb": "ad3ea60262de408767786d37a54d45dc",
+ "lib/puppet/parser/functions/prefix.rb": "e377fd64bd63dde6c9660aa75aca4942",
+ "lib/puppet/parser/functions/private.rb": "1500a21d5cf19961c5b1d476df892d92",
+ "lib/puppet/parser/functions/pw_hash.rb": "02ed57b9b2b1e6266aa52d9680eed412",
+ "lib/puppet/parser/functions/range.rb": "b8bbbc3179ea8e1c84952137cfc97cd0",
+ "lib/puppet/parser/functions/reject.rb": "689f6a7c961a55fe9dcd240921f4c7f9",
+ "lib/puppet/parser/functions/reverse.rb": "b234b54b8cd62b2d67ccd70489ffdccf",
+ "lib/puppet/parser/functions/rstrip.rb": "b4e4ada41f7c1d2fcad073ce6344980f",
+ "lib/puppet/parser/functions/shuffle.rb": "d50f72b0aeb921e64d2482f62488e2f3",
+ "lib/puppet/parser/functions/size.rb": "8972d48c0f9e487d659bd7326b40b642",
+ "lib/puppet/parser/functions/sort.rb": "504b033b438461ca4f9764feeb017833",
+ "lib/puppet/parser/functions/squeeze.rb": "541f85b4203b55c9931d3d6ecd5c75f8",
+ "lib/puppet/parser/functions/str2bool.rb": "6320f1a50fd28ec027981cd1fb8ffdd0",
+ "lib/puppet/parser/functions/str2saltedsha512.rb": "49afad7b386be38ce53deaefef326e85",
+ "lib/puppet/parser/functions/strftime.rb": "e02e01a598ca5d7d6eee0ba22440304a",
+ "lib/puppet/parser/functions/strip.rb": "85d70ab95492e3e4ca5f0b5ec3f284a9",
+ "lib/puppet/parser/functions/suffix.rb": "109279db4180441e75545dbd5f273298",
+ "lib/puppet/parser/functions/swapcase.rb": "b17a9f3cb0271451d309e4b4f52dd651",
+ "lib/puppet/parser/functions/time.rb": "08d88d52abd1e230e3a2f82107545d48",
+ "lib/puppet/parser/functions/to_bytes.rb": "65437027687b6172173b3a211a799e37",
+ "lib/puppet/parser/functions/type.rb": "4709f7ab8a8aad62d77a3c5d91a3aa08",
+ "lib/puppet/parser/functions/type3x.rb": "f9bf4de8341afb0c677c26b40ec8a2b2",
+ "lib/puppet/parser/functions/union.rb": "137998fe47decf25aede20f0c0155a4c",
+ "lib/puppet/parser/functions/unique.rb": "c1bb4a8aeebd09ba3e4c8bc3702cfd60",
+ "lib/puppet/parser/functions/upcase.rb": "c475c4d9d0ed46bcf0adf5de63ba1e82",
+ "lib/puppet/parser/functions/uriescape.rb": "d912ba09ba3f58c70988e662e05ffbe8",
+ "lib/puppet/parser/functions/validate_absolute_path.rb": "d229bb0ff30405f9c6f505dadfebdc34",
+ "lib/puppet/parser/functions/validate_array.rb": "72b29289b8af1cfc3662ef9be78911b8",
+ "lib/puppet/parser/functions/validate_augeas.rb": "b57e68fca390759782885474dc3ab2d0",
+ "lib/puppet/parser/functions/validate_bool.rb": "a712634a000024398b3c6cd4ecc46463",
+ "lib/puppet/parser/functions/validate_cmd.rb": "57b3b128c035802fb67754eed3a88475",
+ "lib/puppet/parser/functions/validate_hash.rb": "e9cfaca68751524efe16ecf2f958a9a0",
+ "lib/puppet/parser/functions/validate_integer.rb": "53d5a7effe41cdebc5acde2ea718ad31",
+ "lib/puppet/parser/functions/validate_ipv4_address.rb": "a8fb6f0ca36aa460d462c07c2af5d5a2",
+ "lib/puppet/parser/functions/validate_ipv6_address.rb": "4699238e4cad60e7e1428905523eaeb7",
+ "lib/puppet/parser/functions/validate_numeric.rb": "bab908e866b78a51412f827ad9f5cf20",
+ "lib/puppet/parser/functions/validate_re.rb": "c6664b3943bc820415a43f16372dc2a9",
+ "lib/puppet/parser/functions/validate_slength.rb": "7e67c213509b9383707819cc612b2a29",
+ "lib/puppet/parser/functions/validate_string.rb": "cf6a20877a27b1073d63fdd522af50bb",
+ "lib/puppet/parser/functions/values.rb": "066a6e4170e5034edb9a80463dff2bb5",
+ "lib/puppet/parser/functions/values_at.rb": "325a899e0201e8df5bd483fec6f12d76",
+ "lib/puppet/parser/functions/zip.rb": "a89d5e802bc1e63e52020c2ddbaaca2c",
+ "lib/puppet/provider/file_line/ruby.rb": "21807f8ce44552e6ca69d322909189ab",
+ "lib/puppet/type/anchor.rb": "bbd36bb49c3b554f8602d8d3df366c0c",
+ "lib/puppet/type/file_line.rb": "56734a41d7d7e3bcb90b78cdb1cfac22",
+ "manifests/init.pp": "f2ba5f36e7227ed87bbb69034fc0de8b",
+ "manifests/stages.pp": "cc6ed1751d334b0ea278c0335c7f0b5a",
+ "metadata.json": "751bc3ba13674db184b13aded4793357",
+ "spec/acceptance/abs_spec.rb": "538db8d037db814b455a6d741e91bb8d",
+ "spec/acceptance/any2array_spec.rb": "de86ead0205acbb3eca3a8a4792bdac8",
+ "spec/acceptance/base64_spec.rb": "1684d5dd176dd5bbd4c3c6b1e64fbcea",
+ "spec/acceptance/bool2num_spec.rb": "bf53ceac40d0a67551c618b11809f3f8",
+ "spec/acceptance/build_csv.rb": "f28ef587de764ade1513091c4906412c",
+ "spec/acceptance/capitalize_spec.rb": "e77ea2c37144a75a67969c0d0839adfd",
+ "spec/acceptance/ceiling_spec.rb": "b2718dc74a39399e342ef96fe0d00fdc",
+ "spec/acceptance/chomp_spec.rb": "fb0862a6b7eeb3c290e280788e705061",
+ "spec/acceptance/chop_spec.rb": "4e7ab2d3a441b88b667a0d8ea5b174c1",
+ "spec/acceptance/concat_spec.rb": "6d88764fde8859e2db6b604f69fe2e17",
+ "spec/acceptance/count_spec.rb": "d82cfcad2461b16872455d6347a8b114",
+ "spec/acceptance/deep_merge_spec.rb": "c335a947f1666e185e0210e661f1c78a",
+ "spec/acceptance/defined_with_params_spec.rb": "f27c54ade9872c63c69316f62b03c119",
+ "spec/acceptance/delete_at_spec.rb": "9c028b703ee0286565c9877757678f3f",
+ "spec/acceptance/delete_spec.rb": "31e6dfcb9cc7c16b20d47c00e6a85a1d",
+ "spec/acceptance/delete_undef_values_spec.rb": "6e6a66aee0c383c843b5f92ef8c8410c",
+ "spec/acceptance/delete_values_spec.rb": "22c9b4914d4cbc0153aa3862cb4fb50e",
+ "spec/acceptance/difference_spec.rb": "289f4f1788feaacb304ffd54971c7e7e",
+ "spec/acceptance/dirname_spec.rb": "84db53878c4400a6c684c924cff05cfc",
+ "spec/acceptance/downcase_spec.rb": "0f094849b94a94df491ee01186473104",
+ "spec/acceptance/empty_spec.rb": "35c1f43e8a3e1fe7dd4335ef86e7efcc",
+ "spec/acceptance/ensure_packages_spec.rb": "de93ff46bcdff523f5636d05b449f6be",
+ "spec/acceptance/ensure_resource_spec.rb": "3e3e9b26ec6cd770469998e3eff49e00",
+ "spec/acceptance/flatten_spec.rb": "83fb08cc168a105c1d5d0df66b1d9e84",
+ "spec/acceptance/floor_spec.rb": "d7267b2914b1da6406224abb7489ca86",
+ "spec/acceptance/fqdn_rand_string_spec.rb": "52fbcdc2b6db4ddf8a63ca759b1a604e",
+ "spec/acceptance/fqdn_rotate_spec.rb": "43ef31f9f2c2616572753cb2b872984e",
+ "spec/acceptance/get_module_path_spec.rb": "2658cdcd1abd4b7d20f53c4aced3c72a",
+ "spec/acceptance/getparam_spec.rb": "4d32dc5a0ee34d045242c36d77a3b482",
+ "spec/acceptance/getvar_spec.rb": "ba2f081a88be97c0e7004a6296294f23",
+ "spec/acceptance/grep_spec.rb": "98818b8b0557b80d6ff519f70ea7617c",
+ "spec/acceptance/has_interface_with_spec.rb": "30e27096050c43b7efdb5e6c0d54f53b",
+ "spec/acceptance/has_ip_address_spec.rb": "2812117ec4b88556039e8488d53c0cb0",
+ "spec/acceptance/has_ip_network_spec.rb": "ca75b43ff1256ead9052f2db7620db99",
+ "spec/acceptance/has_key_spec.rb": "6509a26a0886f7d591eaa926b2f92407",
+ "spec/acceptance/hash_spec.rb": "1c626457ba056bdd3936e28aa5bf503e",
+ "spec/acceptance/intersection_spec.rb": "40f586af7f95408a5d4a2882a4aa98f1",
+ "spec/acceptance/is_array_spec.rb": "c2ff70ce59b90b50a5aed67abaa5399d",
+ "spec/acceptance/is_bool_spec.rb": "c001fdecff6b0a3c9dc78774987a0b15",
+ "spec/acceptance/is_domain_name_spec.rb": "63e84285c26d8717fd5d4dda01e3f432",
+ "spec/acceptance/is_float_spec.rb": "2f0164b4d732166aa46055a2cf7b4ea9",
+ "spec/acceptance/is_function_available_spec.rb": "7745eba89f8719c9ca7ebf04d5b005f7",
+ "spec/acceptance/is_hash_spec.rb": "cff723cd8fddac45033af5dc8406d4e4",
+ "spec/acceptance/is_integer_spec.rb": "c09201d17d3914bba197872897fa3413",
+ "spec/acceptance/is_ip_address_spec.rb": "aa14cf9abf404c3fe1e761ea957871fe",
+ "spec/acceptance/is_mac_address_spec.rb": "30ff4c6a63be58daa3568305617ca2a7",
+ "spec/acceptance/is_numeric_spec.rb": "fb9829c7a1a8d4a58836df6ff4c3386d",
+ "spec/acceptance/is_string_spec.rb": "df3022de123b72f0022728eb2d8ce857",
+ "spec/acceptance/join_keys_to_values_spec.rb": "8aa128bbaeea65aab8d92badee3ca2b5",
+ "spec/acceptance/join_spec.rb": "c6378ed481265152bba9871fc5501ee6",
+ "spec/acceptance/keys_spec.rb": "20486e3ebee53e50dc9de3b78b9d6ae6",
+ "spec/acceptance/loadyaml_spec.rb": "bd440cb6779026bd07d83f1aceb2781b",
+ "spec/acceptance/lstrip_spec.rb": "e29ab4039b65660ec2bd76a298adcae0",
+ "spec/acceptance/max_spec.rb": "209cda4b83d677743afb1a8870330618",
+ "spec/acceptance/member_spec.rb": "d6088a4fa6321791a3067d9b9cf8914a",
+ "spec/acceptance/merge_spec.rb": "5f168188fa0d6b31ba5b3dac49fb609c",
+ "spec/acceptance/min_spec.rb": "152a7db28434a0d0378561d4f64cddcc",
+ "spec/acceptance/nodesets/centos-59-x64.yml": "57eb3e471b9042a8ea40978c467f8151",
+ "spec/acceptance/nodesets/centos-6-vcloud.yml": "bdf9ce9d3b0f0b4995666ae9d64d878d",
+ "spec/acceptance/nodesets/centos-64-x64-pe.yml": "ec075d95760df3d4702abea1ce0a829b",
+ "spec/acceptance/nodesets/centos-64-x64.yml": "092dd2c588a9f87fa1fb12997c0723ef",
+ "spec/acceptance/nodesets/centos-65-x64.yml": "3e5c36e6aa5a690229e720f4048bb8af",
+ "spec/acceptance/nodesets/default.yml": "3e5c36e6aa5a690229e720f4048bb8af",
+ "spec/acceptance/nodesets/fedora-18-x64.yml": "80e41b1ee16ea489f53164bfdae58855",
+ "spec/acceptance/nodesets/sles-11-x64.yml": "44e4c6c15c018333bfa9840a5e702f66",
+ "spec/acceptance/nodesets/ubuntu-server-10044-x64.yml": "75e86400b7889888dc0781c0ae1a1297",
+ "spec/acceptance/nodesets/ubuntu-server-12042-x64.yml": "d30d73e34cd50b043c7d14e305955269",
+ "spec/acceptance/nodesets/ubuntu-server-1404-x64.yml": "5f0aed10098ac5b78e4217bb27c7aaf0",
+ "spec/acceptance/nodesets/windows-2003-i386.yml": "b518fc01fab99ee6a9afccec5bc0c1c4",
+ "spec/acceptance/nodesets/windows-2003-x86_64.yml": "5c783eaa8ea4734edc836e89e923dfa1",
+ "spec/acceptance/nodesets/windows-2008-x86_64.yml": "3082234eafcfaf7a9579d9ebdb8bc409",
+ "spec/acceptance/nodesets/windows-2008r2-x86_64.yml": "dfeff32a4cc3fffa872c8281d990a840",
+ "spec/acceptance/nodesets/windows-2012-x86_64.yml": "8bed73362ee1f43d21ea1903a729f955",
+ "spec/acceptance/nodesets/windows-2012r2-x86_64.yml": "3f4f6112d24db02989b8ab79d3a1256f",
+ "spec/acceptance/num2bool_spec.rb": "e4a00b913b08c68a689837e9f9336cb2",
+ "spec/acceptance/parsejson_spec.rb": "ea3973d412ad6f72425fdfac6fbb2bb4",
+ "spec/acceptance/parseyaml_spec.rb": "7bbfeed73d0626f69daedfc151957967",
+ "spec/acceptance/pick_default_spec.rb": "1bc2562380ef6f6cded5ec90a03922be",
+ "spec/acceptance/pick_spec.rb": "272c54c8f9398f499768331bdb4276ee",
+ "spec/acceptance/prefix_spec.rb": "da620568c6771e7d492ec1ff697c531c",
+ "spec/acceptance/pw_hash_spec.rb": "50d2f3a3ba9a4a7d2fe42f941f9ecd54",
+ "spec/acceptance/range_spec.rb": "65e5b98ceca257658604d988fbec7d03",
+ "spec/acceptance/reject_spec.rb": "b5185f1a6071c9bdc7aca92e6f899c3e",
+ "spec/acceptance/reverse_spec.rb": "7bdee543e82532e97bbf7a067140031c",
+ "spec/acceptance/rstrip_spec.rb": "28a64ceb7cb5ae8a93d31f49816190ab",
+ "spec/acceptance/shuffle_spec.rb": "8a8652e57d56f2b4946cdf4d20052b7a",
+ "spec/acceptance/size_spec.rb": "ae17d8a55921a0570972200c7c9327e1",
+ "spec/acceptance/sort_spec.rb": "d44b1b8c090f0f00a2f38515fda431ea",
+ "spec/acceptance/squeeze_spec.rb": "adcd65fa4e72203b97f1f14c8835c2cd",
+ "spec/acceptance/str2bool_spec.rb": "55ad165ceef6b9ba32bf20ca3b53b44c",
+ "spec/acceptance/str2saltedsha512_spec.rb": "b684c4214d06ae3d5bae055262a5ccaa",
+ "spec/acceptance/strftime_spec.rb": "0f4eadbd74445b35de4a42c9790fbcc1",
+ "spec/acceptance/strip_spec.rb": "6767da5bc735beb5362aeee6ff692c9e",
+ "spec/acceptance/suffix_spec.rb": "07dfc7eed48b75fcc1b93d0308243eda",
+ "spec/acceptance/swapcase_spec.rb": "5c3c1bc19a09fed6e01881f79b0b4ea5",
+ "spec/acceptance/time_spec.rb": "044b2f634a1fa6ecc735998d68a93b73",
+ "spec/acceptance/to_bytes_spec.rb": "f9df1f234b9409f5eaf56ef24e651c36",
+ "spec/acceptance/type_spec.rb": "4297e038a8ff7e6ecb859b8b68c7b3a6",
+ "spec/acceptance/union_spec.rb": "b6092941e0574f3c60910bebf84d2844",
+ "spec/acceptance/unique_spec.rb": "9b00b21cefde3b5391f50eeb9cd2493b",
+ "spec/acceptance/unsupported_spec.rb": "09b9265ecb05252cd5e5a18327c7ae97",
+ "spec/acceptance/upcase_spec.rb": "ffd1d6f9e6ec24131fb78983c53a75f9",
+ "spec/acceptance/uriescape_spec.rb": "13daa387714cbfc63b587aaa8dbf7fcd",
+ "spec/acceptance/validate_absolute_path_spec.rb": "8b9ebfae80329231d84fcab606a3eeaf",
+ "spec/acceptance/validate_array_spec.rb": "382641719e754622ffae562d10e38bf7",
+ "spec/acceptance/validate_augeas_spec.rb": "c26b8ca2184a9dd87033a0c6f0553093",
+ "spec/acceptance/validate_bool_spec.rb": "08bc139459204cf0a35098a5bc30ab95",
+ "spec/acceptance/validate_cmd_spec.rb": "e9260c49d880e4de54f77bf4fd70cff4",
+ "spec/acceptance/validate_hash_spec.rb": "70ceacc18a0dee97b26ab2e50f925706",
+ "spec/acceptance/validate_ipv4_address_spec.rb": "dc901bbd05c3764a93cb49154cea6e4b",
+ "spec/acceptance/validate_ipv6_address_spec.rb": "c0872c56230ac2800cd5723eaa5bc53a",
+ "spec/acceptance/validate_re_spec.rb": "b289909078d6ae0d015419f518566698",
+ "spec/acceptance/validate_slength_spec.rb": "f0a05c1c2b895b096cb7326df4821594",
+ "spec/acceptance/validate_string_spec.rb": "6c9ced99fb1e263e66e25427d24f8f7b",
+ "spec/acceptance/values_at_spec.rb": "669b26c4d47742051472003518c3aa61",
+ "spec/acceptance/values_spec.rb": "9681223bb1bd755c28946ef0bcd6ece9",
+ "spec/acceptance/zip_spec.rb": "86d1b555745ee873da68c71f1e46ed21",
+ "spec/classes/anchor_spec.rb": "40600ba2845f9bd360a9504a347f12ba",
+ "spec/functions/abs_spec.rb": "6c3a4f6072cf28132c29ff42791c0d11",
+ "spec/functions/any2array_spec.rb": "2feb23a3615dc55d5e99ae8617f4aca3",
+ "spec/functions/assert_private_spec.rb": "192cf2b9763ab7b741f19a146c069601",
+ "spec/functions/base64_spec.rb": "c93bdf30f5894728fe6558eb24955e26",
+ "spec/functions/bool2num_spec.rb": "12d7f3074beaf3a8b5c06da39b8f5a88",
+ "spec/functions/capitalize_spec.rb": "da52f8dd560b2a2ed57f13019b0b8302",
+ "spec/functions/ceiling_spec.rb": "aa2e9b34a10f7fbda4b33bfc8f5dadcd",
+ "spec/functions/chomp_spec.rb": "dea81927a4c134e2a47500969324c70e",
+ "spec/functions/chop_spec.rb": "3b0d0335f5e3347b7a9815e58b923657",
+ "spec/functions/concat_spec.rb": "e8377bd292819360ffc5359c86adbff2",
+ "spec/functions/count_spec.rb": "25e6e666561ced6d644d62bd71a648c6",
+ "spec/functions/deep_merge_spec.rb": "84f4f2cc194de907143ea17a3d40687e",
+ "spec/functions/defined_with_params_spec.rb": "498e064c37bb330dc80420e877e4e57d",
+ "spec/functions/delete_at_spec.rb": "012b3399d4a7101fc4cd4938e9bd2d50",
+ "spec/functions/delete_spec.rb": "889f0a0d5a8eb12ad6ee93e98601600d",
+ "spec/functions/delete_undef_values_spec.rb": "d61453c547c8816128e0a5e358821248",
+ "spec/functions/delete_values_spec.rb": "737cf476b579fb7b549280eb20d13ae7",
+ "spec/functions/difference_spec.rb": "2d7c07bc8bcb82831fcfe2f2a9958605",
+ "spec/functions/dirname_spec.rb": "b35d4806c8167478a6c45e0b63623513",
+ "spec/functions/downcase_spec.rb": "0864d43eb33e5d46a5943c2d117bfa40",
+ "spec/functions/empty_spec.rb": "046c8206121e364eb9b11bfb378e591b",
+ "spec/functions/ensure_packages_spec.rb": "f1b60599078cdcb3cff1368346108264",
+ "spec/functions/ensure_resource_spec.rb": "7765dde3b9fc54b7dddb6597e0f7b523",
+ "spec/functions/flatten_spec.rb": "a830987eb5b26a1b4325a7737fb9a7e2",
+ "spec/functions/floor_spec.rb": "d53e184f732c7b0fa49664645d6fb63d",
+ "spec/functions/fqdn_rand_string_spec.rb": "4d01df1bb76c413692ff5c035c4ac9df",
+ "spec/functions/fqdn_rotate_spec.rb": "0fecb71063ed7e8cf3b1e4b67699bb4a",
+ "spec/functions/get_module_path_spec.rb": "632de3cddb0980998b1f7f819feda3b4",
+ "spec/functions/getparam_spec.rb": "292346901bc0083a983fc166fee44675",
+ "spec/functions/getvar_spec.rb": "e0fa7cde8c415d099cd31888670ca2fc",
+ "spec/functions/grep_spec.rb": "aa5ab60a3899a4286152fbd5d3218bd3",
+ "spec/functions/has_interface_with_spec.rb": "2abef34f38bf2369434f27ab5ab02e0f",
+ "spec/functions/has_ip_address_spec.rb": "89d2a1e161ba9efdec36f90e1b7737bf",
+ "spec/functions/has_ip_network_spec.rb": "b0c080fa6fa27f03a0999a07b4cfbd08",
+ "spec/functions/has_key_spec.rb": "63f35c643a8a0ac1f3281b2981b4ab26",
+ "spec/functions/hash_spec.rb": "f85918bdeb33c2b0dc276fda46528d56",
+ "spec/functions/intersection_spec.rb": "fa5e91bec7bcf48c5d4b66e2824ba629",
+ "spec/functions/is_array_spec.rb": "82266ebdbc4002dc4471eb19095a617d",
+ "spec/functions/is_bool_spec.rb": "f8075f0d7b79b5568a646d97fb4e8115",
+ "spec/functions/is_domain_name_spec.rb": "35c18882c7a3bc361e72c3ca09e73c74",
+ "spec/functions/is_float_spec.rb": "adf03894b9e78f1e66831ba52ac20f49",
+ "spec/functions/is_function_available.rb": "193666f87f9a739a77335d9171411f5f",
+ "spec/functions/is_hash_spec.rb": "f1906d7cacf56f0ed26f703a3c4e19c4",
+ "spec/functions/is_integer_spec.rb": "5ed8c0620c64a4e8a6a07105816ae1f4",
+ "spec/functions/is_ip_address_spec.rb": "1c3ce0f2f9b6354d6ea7ffa36731d94c",
+ "spec/functions/is_mac_address_spec.rb": "60b1ea6464e10f3c8a095af0b69a1f4a",
+ "spec/functions/is_numeric_spec.rb": "6ceee608830d8d3c37a0d52d253e5ed1",
+ "spec/functions/is_string_spec.rb": "b67b213edc19f0bd97b2e4e561b4688b",
+ "spec/functions/join_keys_to_values_spec.rb": "444289422833c4d932432cba336d79ff",
+ "spec/functions/join_spec.rb": "35fe86a4a49befe39452eb861f3c66ff",
+ "spec/functions/keys_spec.rb": "6ada6f2263dda5a22b0505bab90c1543",
+ "spec/functions/loadyaml_spec.rb": "7d688e8382dd47db93dc4c710f8d6010",
+ "spec/functions/lstrip_spec.rb": "3161f3673f327aed9488958bbb91d720",
+ "spec/functions/max_spec.rb": "0ced8af1760cb387e7b8f4bc014fc94b",
+ "spec/functions/member_spec.rb": "8ac9f5d1aee5b3f503532fd54d9f609d",
+ "spec/functions/merge_spec.rb": "791ea69c46145b9c39f65f8d241a1205",
+ "spec/functions/min_spec.rb": "b13e21751bfacc850019fa4c7c177536",
+ "spec/functions/num2bool_spec.rb": "837bc45de67428a3c1faf8e22bb7dcf1",
+ "spec/functions/parsejson_spec.rb": "76e923a21cc6ddd38edf9a18e52991ae",
+ "spec/functions/parseyaml_spec.rb": "ebc620457c14d268a3f313277ab5ff46",
+ "spec/functions/pick_default_spec.rb": "dbfcee6a55488e8cb0af0866e1297f8c",
+ "spec/functions/pick_spec.rb": "c7ae8b1aa7eb615c9164d3cccfc891fb",
+ "spec/functions/prefix_spec.rb": "79de342f14f025114c0cd36ab23a7bf9",
+ "spec/functions/private_spec.rb": "367348d2d5a089fd5a77f1852fc56168",
+ "spec/functions/pw_hash_spec.rb": "f138aa3182e98b9eb06d5ed99579444c",
+ "spec/functions/range_spec.rb": "17ff3b8d7ead0939519c38d993fe2347",
+ "spec/functions/reject_spec.rb": "12cd8e9b98234dbfca06b33af4152bf3",
+ "spec/functions/reverse_spec.rb": "4dc357880ba5d3716c53d73e2045466a",
+ "spec/functions/rstrip_spec.rb": "af0d0c8b18c772f10e8227b3e9d8a54a",
+ "spec/functions/shuffle_spec.rb": "de716009e14609112b0209570dc69b06",
+ "spec/functions/size_spec.rb": "7551af6a9055650c863431ee6f9c82f5",
+ "spec/functions/sort_spec.rb": "c548fee79b5e86e5371371dbb36982db",
+ "spec/functions/squeeze_spec.rb": "aa7d260c8840e0eb4b72def5e0f63d96",
+ "spec/functions/str2bool_spec.rb": "1b854776e182f528d72f624a581e1a19",
+ "spec/functions/str2saltedsha512_spec.rb": "284430b18af76f42d60ad2db4c5e265a",
+ "spec/functions/strftime_spec.rb": "55b2abeecb65d147136d6af49ce61924",
+ "spec/functions/strip_spec.rb": "ac5316d9357fecba9ac55bdb0eb0ac29",
+ "spec/functions/suffix_spec.rb": "217ff8dc2f509b860af7c7c9ff73134b",
+ "spec/functions/swapcase_spec.rb": "686d6ff7c7a1fd473d2a74a1c3bbe8ca",
+ "spec/functions/time_spec.rb": "1a2db01a57ed1437b19cdeaaabc2c77e",
+ "spec/functions/to_bytes_spec.rb": "f0b0fbb9919bbe3882ca0d8f8db2c3b8",
+ "spec/functions/type3x_spec.rb": "dcbb17597f5040b4f02f7d035fa24eb7",
+ "spec/functions/type_spec.rb": "4a09d1fd50a3c787aba1bc82dbe9ae3b",
+ "spec/functions/union_spec.rb": "db5d5a0aa8c29725936e2488ccbcfd0a",
+ "spec/functions/unique_spec.rb": "42f9b82d1df269a1b34f4562369b8b84",
+ "spec/functions/upcase_spec.rb": "a4797eddc5cbddf006a1255d95f429ad",
+ "spec/functions/uriescape_spec.rb": "021fe7a48be167eab45318ca5890dcfd",
+ "spec/functions/validate_absolute_path_spec.rb": "6d8fa2007ba1490ef0a4082fad569d5b",
+ "spec/functions/validate_array_spec.rb": "bcd231229554785c4270ca92ef99cb60",
+ "spec/functions/validate_augeas_spec.rb": "57214b36976344d5fdec1171cb31485e",
+ "spec/functions/validate_bool_spec.rb": "7aeb6085fc9601c6bbe6c49e56d209a4",
+ "spec/functions/validate_cmd_spec.rb": "0fbecaf7616ba5a8ae6447082c9804bc",
+ "spec/functions/validate_hash_spec.rb": "8529c74051ceb71e6b1b97c9cecdf625",
+ "spec/functions/validate_integer_spec.rb": "860949498dfa7dc29cfc4d0cfb319619",
+ "spec/functions/validate_ipv4_address_spec.rb": "19f2f44fbbdf7a2e69aeaa2f0f402695",
+ "spec/functions/validate_ipv6_address_spec.rb": "2d8617be4405bdbd84d140ba8be6c184",
+ "spec/functions/validate_numeric_spec.rb": "c2ce1a20ec9d45f69852c8d973f52fd9",
+ "spec/functions/validate_re_spec.rb": "d8ab477f9afcb748f144588ebb3a28a3",
+ "spec/functions/validate_slength_spec.rb": "438738f1ac9363d5a7cd8c3ee09fe14c",
+ "spec/functions/validate_string_spec.rb": "64a4f681084cba55775a070f7fab5e0c",
+ "spec/functions/values_at_spec.rb": "cdfc313cc283400f1aed75f4cbd0ab4f",
+ "spec/functions/values_spec.rb": "2ea5dd37e6ac9c89f4b434c7ed7cc45e",
+ "spec/functions/zip_spec.rb": "d67e3424e60de00ff26e73516f4bf6da",
+ "spec/lib/puppet_spec/compiler.rb": "3c1f03dd8ac2f6f90d7e8f879a3ce4c0",
+ "spec/lib/puppet_spec/database.rb": "c74c0cf62980beea88c7749f876ccfa7",
+ "spec/lib/puppet_spec/files.rb": "906da85e399302cee403e10e357d3f4c",
+ "spec/lib/puppet_spec/fixtures.rb": "0722c5ccbfcba1fc27da1900e54b4463",
+ "spec/lib/puppet_spec/matchers.rb": "dd30ba6b936e8c267511d67acb087c35",
+ "spec/lib/puppet_spec/modules.rb": "445d2739aa8754568a14816280727d70",
+ "spec/lib/puppet_spec/pops.rb": "adf661defa460b7189e3750535533d34",
+ "spec/lib/puppet_spec/scope.rb": "01aeb89bdc2d29a2528ced26ec6402ec",
+ "spec/lib/puppet_spec/settings.rb": "5da4e0dad8bf6b21cc4437c73753a56d",
+ "spec/lib/puppet_spec/verbose.rb": "71dbccd9a45ed89d12fd1c44456a6820",
+ "spec/monkey_patches/alias_should_to_must.rb": "b19ee31563afb91a72f9869f9d7362ff",
+ "spec/monkey_patches/publicize_methods.rb": "c690e444b77c871375d321e413e28ca1",
+ "spec/spec.opts": "a600ded995d948e393fbe2320ba8e51c",
+ "spec/spec_helper.rb": "b7a797512ad4ae4395fa5d1ff524e1f0",
+ "spec/spec_helper_acceptance.rb": "ffb989c77153f8206c9be08f32278147",
+ "spec/unit/facter/facter_dot_d_spec.rb": "420339a544851f2c7ee6fa4c651bdce8",
+ "spec/unit/facter/pe_version_spec.rb": "af4d4428a7625a19de1751ce1bb09d5c",
+ "spec/unit/facter/root_home_spec.rb": "2dabfc67279e85714e0d4479bd149e78",
+ "spec/unit/facter/util/puppet_settings_spec.rb": "7b4afdfe4b80ee6463564bda2c4af344",
+ "spec/unit/puppet/functions/type_of_spec.rb": "3fe581c5de01b6f6338370e475b6b1b2",
+ "spec/unit/puppet/parser/functions/basename_spec.rb": "e7ac349b8336c6a2bb99f27443a9d077",
+ "spec/unit/puppet/parser/functions/bool2str_spec.rb": "c0a7f753889d0e65c25db5b0eebad7ac",
+ "spec/unit/puppet/parser/functions/camelcase_spec.rb": "332621f98485c651b281aa4b5ac82b5d",
+ "spec/unit/puppet/provider/file_line/ruby_spec.rb": "e8dcf08c5cd346a6408d8da4fa0bbf7e",
+ "spec/unit/puppet/type/anchor_spec.rb": "06a669dffa44d716bf19b4e7f5f1d75d",
+ "spec/unit/puppet/type/file_line_spec.rb": "5800799a8d3aed42c6fb6cf3ea574e07",
+ "tests/file_line.pp": "67727539aa7b7dd76f06626fe734f7f7",
+ "tests/has_interface_with.pp": "59c98b4af0d39fc11d1ef4c7a6dc8f7a",
+ "tests/has_ip_address.pp": "93ce02915f67ddfb43a049b2b84ef391",
+ "tests/has_ip_network.pp": "abc05686797a776ea8c054657e6f7456",
+ "tests/init.pp": "1d98070412c76824e66db4b7eb74d433"
+}
\ No newline at end of file
--- /dev/null
+# A Facter plugin that loads facts from /etc/facter/facts.d
+# and /etc/puppetlabs/facter/facts.d.
+#
+# Facts can be in the form of JSON, YAML or Text files
+# and any executable that returns key=value pairs.
+#
+# In the case of scripts you can also create a file that
+# contains a cache TTL. For foo.sh store the ttl as just
+# a number in foo.sh.ttl
+#
+# The cache is stored in /tmp/facts_cache.yaml as a mode
+# 600 file and will have the end result of not calling your
+# fact scripts more often than is needed
+
+class Facter::Util::DotD
+ require 'yaml'
+
+ def initialize(dir="/etc/facts.d", cache_file=File.join(Puppet[:libdir], "facts_dot_d.cache"))
+ @dir = dir
+ @cache_file = cache_file
+ @cache = nil
+ @types = {".txt" => :txt, ".json" => :json, ".yaml" => :yaml}
+ end
+
+ def entries
+ Dir.entries(@dir).reject { |f| f =~ /^\.|\.ttl$/ }.sort.map { |f| File.join(@dir, f) }
+ rescue
+ []
+ end
+
+ def fact_type(file)
+ extension = File.extname(file)
+
+ type = @types[extension] || :unknown
+
+ type = :script if type == :unknown && File.executable?(file)
+
+ return type
+ end
+
+ def txt_parser(file)
+ File.readlines(file).each do |line|
+ if line =~ /^([^=]+)=(.+)$/
+ var = $1; val = $2
+
+ Facter.add(var) do
+ setcode { val }
+ end
+ end
+ end
+ rescue Exception => e
+ Facter.warn("Failed to handle #{file} as text facts: #{e.class}: #{e}")
+ end
+
+ def json_parser(file)
+ begin
+ require 'json'
+ rescue LoadError
+ retry if require 'rubygems'
+ raise
+ end
+
+ JSON.load(File.read(file)).each_pair do |f, v|
+ Facter.add(f) do
+ setcode { v }
+ end
+ end
+ rescue Exception => e
+ Facter.warn("Failed to handle #{file} as json facts: #{e.class}: #{e}")
+ end
+
+ def yaml_parser(file)
+ require 'yaml'
+
+ YAML.load_file(file).each_pair do |f, v|
+ Facter.add(f) do
+ setcode { v }
+ end
+ end
+ rescue Exception => e
+ Facter.warn("Failed to handle #{file} as yaml facts: #{e.class}: #{e}")
+ end
+
+ def script_parser(file)
+ result = cache_lookup(file)
+ ttl = cache_time(file)
+
+ unless result
+ result = Facter::Util::Resolution.exec(file)
+
+ if ttl > 0
+ Facter.debug("Updating cache for #{file}")
+ cache_store(file, result)
+ cache_save!
+ end
+ else
+ Facter.debug("Using cached data for #{file}")
+ end
+
+ result.split("\n").each do |line|
+ if line =~ /^(.+)=(.+)$/
+ var = $1; val = $2
+
+ Facter.add(var) do
+ setcode { val }
+ end
+ end
+ end
+ rescue Exception => e
+ Facter.warn("Failed to handle #{file} as script facts: #{e.class}: #{e}")
+ Facter.debug(e.backtrace.join("\n\t"))
+ end
+
+ def cache_save!
+ cache = load_cache
+ File.open(@cache_file, "w", 0600) { |f| f.write(YAML.dump(cache)) }
+ rescue
+ end
+
+ def cache_store(file, data)
+ load_cache
+
+ @cache[file] = {:data => data, :stored => Time.now.to_i}
+ rescue
+ end
+
+ def cache_lookup(file)
+ cache = load_cache
+
+ return nil if cache.empty?
+
+ ttl = cache_time(file)
+
+ if cache[file]
+ now = Time.now.to_i
+
+ return cache[file][:data] if ttl == -1
+ return cache[file][:data] if (now - cache[file][:stored]) <= ttl
+ return nil
+ else
+ return nil
+ end
+ rescue
+ return nil
+ end
+
+ def cache_time(file)
+ meta = file + ".ttl"
+
+ return File.read(meta).chomp.to_i
+ rescue
+ return 0
+ end
+
+ def load_cache
+ unless @cache
+ if File.exist?(@cache_file)
+ @cache = YAML.load_file(@cache_file)
+ else
+ @cache = {}
+ end
+ end
+
+ return @cache
+ rescue
+ @cache = {}
+ return @cache
+ end
+
+ def create
+ entries.each do |fact|
+ type = fact_type(fact)
+ parser = "#{type}_parser"
+
+ if respond_to?("#{type}_parser")
+ Facter.debug("Parsing #{fact} using #{parser}")
+
+ send(parser, fact)
+ end
+ end
+ end
+end
+
+
+mdata = Facter.version.match(/(\d+)\.(\d+)\.(\d+)/)
+if mdata
+ (major, minor, patch) = mdata.captures.map { |v| v.to_i }
+ if major < 2
+ # Facter 1.7 introduced external facts support directly
+ unless major == 1 and minor > 6
+ Facter::Util::DotD.new("/etc/facter/facts.d").create
+ Facter::Util::DotD.new("/etc/puppetlabs/facter/facts.d").create
+
+ # Windows has a different configuration directory that defaults to a vendor
+ # specific sub directory of the %COMMON_APPDATA% directory.
+ if Dir.const_defined? 'COMMON_APPDATA' then
+ windows_facts_dot_d = File.join(Dir::COMMON_APPDATA, 'PuppetLabs', 'facter', 'facts.d')
+ Facter::Util::DotD.new(windows_facts_dot_d).create
+ end
+ end
+ end
+end
--- /dev/null
+# Fact: is_pe, pe_version, pe_major_version, pe_minor_version, pe_patch_version
+#
+# Purpose: Return various facts about the PE state of the system
+#
+# Resolution: Uses a regex match against puppetversion to determine whether the
+# machine has Puppet Enterprise installed, and what version (overall, major,
+# minor, patch) is installed.
+#
+# Caveats:
+#
+Facter.add("pe_version") do
+ setcode do
+ pe_ver = Facter.value("puppetversion").match(/Puppet Enterprise (\d+\.\d+\.\d+)/)
+ pe_ver[1] if pe_ver
+ end
+end
+
+Facter.add("is_pe") do
+ setcode do
+ if Facter.value(:pe_version).to_s.empty? then
+ false
+ else
+ true
+ end
+ end
+end
+
+Facter.add("pe_major_version") do
+ confine :is_pe => true
+ setcode do
+ if pe_version = Facter.value(:pe_version)
+ pe_version.to_s.split('.')[0]
+ end
+ end
+end
+
+Facter.add("pe_minor_version") do
+ confine :is_pe => true
+ setcode do
+ if pe_version = Facter.value(:pe_version)
+ pe_version.to_s.split('.')[1]
+ end
+ end
+end
+
+Facter.add("pe_patch_version") do
+ confine :is_pe => true
+ setcode do
+ if pe_version = Facter.value(:pe_version)
+ pe_version.to_s.split('.')[2]
+ end
+ end
+end
--- /dev/null
+# This facter fact returns the value of the Puppet vardir setting for the node
+# running puppet or puppet agent. The intent is to enable Puppet modules to
+# automatically have insight into a place where they can place variable data,
+# regardless of the node's platform.
+#
+# The value should be directly usable in a File resource path attribute.
+
+
+begin
+ require 'facter/util/puppet_settings'
+rescue LoadError => e
+ # puppet apply does not add module lib directories to the $LOAD_PATH (See
+ # #4248). It should (in the future) but for the time being we need to be
+ # defensive which is what this rescue block is doing.
+ rb_file = File.join(File.dirname(__FILE__), 'util', 'puppet_settings.rb')
+ load rb_file if File.exists?(rb_file) or raise e
+end
+
+Facter.add(:puppet_vardir) do
+ setcode do
+ # This will be nil if Puppet is not available.
+ Facter::Util::PuppetSettings.with_puppet do
+ Puppet[:vardir]
+ end
+ end
+end
--- /dev/null
+# A facter fact to determine the root home directory.
+# This varies on PE supported platforms and may be
+# reconfigured by the end user.
+
+module Facter::Util::RootHome
+ class << self
+ def get_root_home
+ root_ent = Facter::Util::Resolution.exec("getent passwd root")
+ # The home directory is the sixth element in the passwd entry
+ # If the platform doesn't have getent, root_ent will be nil and we should
+ # return it straight away.
+ root_ent && root_ent.split(":")[5]
+ end
+ end
+end
+
+Facter.add(:root_home) do
+ setcode { Facter::Util::RootHome.get_root_home }
+end
+
+Facter.add(:root_home) do
+ confine :kernel => :darwin
+ setcode do
+ str = Facter::Util::Resolution.exec("dscacheutil -q user -a name root")
+ hash = {}
+ str.split("\n").each do |pair|
+ key,value = pair.split(/:/)
+ hash[key] = value
+ end
+ hash['dir'].strip
+ end
+end
--- /dev/null
+module Facter
+ module Util
+ module PuppetSettings
+ # This method is intended to provide a convenient way to evaluate a
+ # Facter code block only if Puppet is loaded. This is to account for the
+ # situation where the fact happens to be in the load path, but Puppet is
+ # not loaded for whatever reason. Perhaps the user is simply running
+ # facter without the --puppet flag and they happen to be working in a lib
+ # directory of a module.
+ def self.with_puppet
+ begin
+ Module.const_get("Puppet")
+ rescue NameError
+ nil
+ else
+ yield
+ end
+ end
+ end
+ end
+end
--- /dev/null
+# Returns the type when passed a value.
+#
+# @example how to compare values' types
+# # compare the types of two values
+# if type_of($first_value) != type_of($second_value) { fail("first_value and second_value are different types") }
+# @example how to compare against an abstract type
+# unless type_of($first_value) <= Numeric { fail("first_value must be Numeric") }
+# unless type_of{$first_value) <= Collection[1] { fail("first_value must be an Array or Hash, and contain at least one element") }
+#
+# See the documentation for "The Puppet Type System" for more information about types.
+# See the `assert_type()` function for flexible ways to assert the type of a value.
+#
+Puppet::Functions.create_function(:type_of) do
+ def type_of(value)
+ Puppet::Pops::Types::TypeCalculator.infer_set(value)
+ end
+end
--- /dev/null
+#
+# abs.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:abs, :type => :rvalue, :doc => <<-EOS
+ Returns the absolute value of a number, for example -34.56 becomes
+ 34.56. Takes a single integer and float value as an argument.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "abs(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ # Numbers in Puppet are often string-encoded which is troublesome ...
+ if value.is_a?(String)
+ if value.match(/^-?(?:\d+)(?:\.\d+){1}$/)
+ value = value.to_f
+ elsif value.match(/^-?\d+$/)
+ value = value.to_i
+ else
+ raise(Puppet::ParseError, 'abs(): Requires float or ' +
+ 'integer to work with')
+ end
+ end
+
+ # We have numeric value to handle ...
+ result = value.abs
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# any2array.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:any2array, :type => :rvalue, :doc => <<-EOS
+This converts any object to an array containing that object. Empty argument
+lists are converted to an empty array. Arrays are left untouched. Hashes are
+converted to arrays of alternating keys and values.
+ EOS
+ ) do |arguments|
+
+ if arguments.empty?
+ return []
+ end
+
+ if arguments.length == 1
+ if arguments[0].kind_of?(Array)
+ return arguments[0]
+ elsif arguments[0].kind_of?(Hash)
+ result = []
+ arguments[0].each do |key, value|
+ result << key << value
+ end
+ return result
+ end
+ end
+
+ return arguments
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# assert_private.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:assert_private, :doc => <<-'EOS'
+ Sets the current class or definition as private.
+ Calling the class or definition from outside the current module will fail.
+ EOS
+ ) do |args|
+
+ raise(Puppet::ParseError, "assert_private(): Wrong number of arguments "+
+ "given (#{args.size}}) for 0 or 1)") if args.size > 1
+
+ scope = self
+ if scope.lookupvar('module_name') != scope.lookupvar('caller_module_name')
+ message = nil
+ if args[0] and args[0].is_a? String
+ message = args[0]
+ else
+ manifest_name = scope.source.name
+ manifest_type = scope.source.type
+ message = (manifest_type.to_s == 'hostclass') ? 'Class' : 'Definition'
+ message += " #{manifest_name} is private"
+ end
+ raise(Puppet::ParseError, message)
+ end
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:base64, :type => :rvalue, :doc => <<-'ENDHEREDOC') do |args|
+
+ Base64 encode or decode a string based on the command and the string submitted
+
+ Usage:
+
+ $encodestring = base64('encode','thestring')
+ $decodestring = base64('decode','dGhlc3RyaW5n')
+
+ ENDHEREDOC
+
+ require 'base64'
+
+ raise Puppet::ParseError, ("base64(): Wrong number of arguments (#{args.length}; must be = 2)") unless args.length == 2
+
+ actions = ['encode','decode']
+
+ unless actions.include?(args[0])
+ raise Puppet::ParseError, ("base64(): the first argument must be one of 'encode' or 'decode'")
+ end
+
+ unless args[1].is_a?(String)
+ raise Puppet::ParseError, ("base64(): the second argument must be a string to base64")
+ end
+
+ case args[0]
+ when 'encode'
+ result = Base64.encode64(args[1])
+ when 'decode'
+ result = Base64.decode64(args[1])
+ end
+
+ return result
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:basename, :type => :rvalue, :doc => <<-EOS
+ Strips directory (and optional suffix) from a filename
+ EOS
+ ) do |arguments|
+
+ if arguments.size < 1 then
+ raise(Puppet::ParseError, "basename(): No arguments given")
+ elsif arguments.size > 2 then
+ raise(Puppet::ParseError, "basename(): Too many arguments given (#{arguments.size})")
+ else
+
+ unless arguments[0].is_a?(String)
+ raise(Puppet::ParseError, 'basename(): Requires string as first argument')
+ end
+
+ if arguments.size == 1 then
+ rv = File.basename(arguments[0])
+ elsif arguments.size == 2 then
+
+ unless arguments[1].is_a?(String)
+ raise(Puppet::ParseError, 'basename(): Requires string as second argument')
+ end
+
+ rv = File.basename(arguments[0], arguments[1])
+ end
+
+ end
+
+ return rv
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# bool2num.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:bool2num, :type => :rvalue, :doc => <<-EOS
+ Converts a boolean to a number. Converts the values:
+ false, f, 0, n, and no to 0
+ true, t, 1, y, and yes to 1
+ Requires a single boolean or string as an input.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "bool2num(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = function_str2bool([arguments[0]])
+
+ # We have real boolean values as well ...
+ result = value ? 1 : 0
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# bool2str.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:bool2str, :type => :rvalue, :doc => <<-EOS
+ Converts a boolean to a string.
+ Requires a single boolean as an input.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "bool2str(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+ klass = value.class
+
+ # We can have either true or false, and nothing else
+ unless [FalseClass, TrueClass].include?(klass)
+ raise(Puppet::ParseError, 'bool2str(): Requires a boolean to work with')
+ end
+
+ return value.to_s
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# camelcase.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:camelcase, :type => :rvalue, :doc => <<-EOS
+Converts the case of a string or all strings in an array to camel case.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "camelcase(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+ klass = value.class
+
+ unless [Array, String].include?(klass)
+ raise(Puppet::ParseError, 'camelcase(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ if value.is_a?(Array)
+ # Numbers in Puppet are often string-encoded which is troublesome ...
+ result = value.collect { |i| i.is_a?(String) ? i.split('_').map{|e| e.capitalize}.join : i }
+ else
+ result = value.split('_').map{|e| e.capitalize}.join
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# capitalize.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:capitalize, :type => :rvalue, :doc => <<-EOS
+ Capitalizes the first letter of a string or array of strings.
+ Requires either a single string or an array as an input.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "capitalize(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'capitalize(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ if value.is_a?(Array)
+ # Numbers in Puppet are often string-encoded which is troublesome ...
+ result = value.collect { |i| i.is_a?(String) ? i.capitalize : i }
+ else
+ result = value.capitalize
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:ceiling, :type => :rvalue, :doc => <<-EOS
+ Returns the smallest integer greater or equal to the argument.
+ Takes a single numeric value as an argument.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "ceiling(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size != 1
+
+ begin
+ arg = Float(arguments[0])
+ rescue TypeError, ArgumentError => e
+ raise(Puppet::ParseError, "ceiling(): Wrong argument type " +
+ "given (#{arguments[0]} for Numeric)")
+ end
+
+ raise(Puppet::ParseError, "ceiling(): Wrong argument type " +
+ "given (#{arg.class} for Numeric)") if arg.is_a?(Numeric) == false
+
+ arg.ceil
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# chomp.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:chomp, :type => :rvalue, :doc => <<-'EOS'
+ Removes the record separator from the end of a string or an array of
+ strings, for example `hello\n` becomes `hello`.
+ Requires a single string or array as an input.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "chomp(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'chomp(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ if value.is_a?(Array)
+ # Numbers in Puppet are often string-encoded which is troublesome ...
+ result = value.collect { |i| i.is_a?(String) ? i.chomp : i }
+ else
+ result = value.chomp
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# chop.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:chop, :type => :rvalue, :doc => <<-'EOS'
+ Returns a new string with the last character removed. If the string ends
+ with `\r\n`, both characters are removed. Applying chop to an empty
+ string returns an empty string. If you wish to merely remove record
+ separators then you should use the `chomp` function.
+ Requires a string or array of strings as input.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "chop(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'chop(): Requires either an ' +
+ 'array or string to work with')
+ end
+
+ if value.is_a?(Array)
+ # Numbers in Puppet are often string-encoded which is troublesome ...
+ result = value.collect { |i| i.is_a?(String) ? i.chop : i }
+ else
+ result = value.chop
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# concat.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:concat, :type => :rvalue, :doc => <<-EOS
+Appends the contents of multiple arrays into array 1.
+
+*Example:*
+
+ concat(['1','2','3'],['4','5','6'],['7','8','9'])
+
+Would result in:
+
+ ['1','2','3','4','5','6','7','8','9']
+ EOS
+ ) do |arguments|
+
+ # Check that more than 2 arguments have been given ...
+ raise(Puppet::ParseError, "concat(): Wrong number of arguments " +
+ "given (#{arguments.size} for < 2)") if arguments.size < 2
+
+ a = arguments[0]
+
+ # Check that the first parameter is an array
+ unless a.is_a?(Array)
+ raise(Puppet::ParseError, 'concat(): Requires array to work with')
+ end
+
+ result = a
+ arguments.shift
+
+ arguments.each do |x|
+ result = result + Array(x)
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:count, :type => :rvalue, :arity => -2, :doc => <<-EOS
+Takes an array as first argument and an optional second argument.
+Count the number of elements in array that matches second argument.
+If called with only an array it counts the number of elements that are not nil/undef.
+ EOS
+ ) do |args|
+
+ if (args.size > 2) then
+ raise(ArgumentError, "count(): Wrong number of arguments "+
+ "given #{args.size} for 1 or 2.")
+ end
+
+ collection, item = args
+
+ if item then
+ collection.count item
+ else
+ collection.count { |obj| obj != nil && obj != :undef && obj != '' }
+ end
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:deep_merge, :type => :rvalue, :doc => <<-'ENDHEREDOC') do |args|
+ Recursively merges two or more hashes together and returns the resulting hash.
+
+ For example:
+
+ $hash1 = {'one' => 1, 'two' => 2, 'three' => { 'four' => 4 } }
+ $hash2 = {'two' => 'dos', 'three' => { 'five' => 5 } }
+ $merged_hash = deep_merge($hash1, $hash2)
+ # The resulting hash is equivalent to:
+ # $merged_hash = { 'one' => 1, 'two' => 'dos', 'three' => { 'four' => 4, 'five' => 5 } }
+
+ When there is a duplicate key that is a hash, they are recursively merged.
+ When there is a duplicate key that is not a hash, the key in the rightmost hash will "win."
+
+ ENDHEREDOC
+
+ if args.length < 2
+ raise Puppet::ParseError, ("deep_merge(): wrong number of arguments (#{args.length}; must be at least 2)")
+ end
+
+ deep_merge = Proc.new do |hash1,hash2|
+ hash1.merge(hash2) do |key,old_value,new_value|
+ if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+ deep_merge.call(old_value, new_value)
+ else
+ new_value
+ end
+ end
+ end
+
+ result = Hash.new
+ args.each do |arg|
+ next if arg.is_a? String and arg.empty? # empty string is synonym for puppet's undef
+ # If the argument was not a hash, skip it.
+ unless arg.is_a?(Hash)
+ raise Puppet::ParseError, "deep_merge: unexpected argument type #{arg.class}, only expects hash arguments"
+ end
+
+ result = deep_merge.call(result, arg)
+ end
+ return( result )
+ end
+end
--- /dev/null
+# Test whether a given class or definition is defined
+require 'puppet/parser/functions'
+
+Puppet::Parser::Functions.newfunction(:defined_with_params,
+ :type => :rvalue,
+ :doc => <<-'ENDOFDOC'
+Takes a resource reference and an optional hash of attributes.
+
+Returns true if a resource with the specified attributes has already been added
+to the catalog, and false otherwise.
+
+ user { 'dan':
+ ensure => present,
+ }
+
+ if ! defined_with_params(User[dan], {'ensure' => 'present' }) {
+ user { 'dan': ensure => present, }
+ }
+ENDOFDOC
+) do |vals|
+ reference, params = vals
+ raise(ArgumentError, 'Must specify a reference') unless reference
+ if (! params) || params == ''
+ params = {}
+ end
+ ret = false
+ if resource = findresource(reference.to_s)
+ matches = params.collect do |key, value|
+ resource[key] == value
+ end
+ ret = params.empty? || !matches.include?(false)
+ end
+ Puppet.debug("Resource #{reference} was not determined to be defined")
+ ret
+end
--- /dev/null
+#
+# delete.rb
+#
+
+# TODO(Krzysztof Wilczynski): We need to add support for regular expression ...
+
+module Puppet::Parser::Functions
+ newfunction(:delete, :type => :rvalue, :doc => <<-EOS
+Deletes all instances of a given element from an array, substring from a
+string, or key from a hash.
+
+*Examples:*
+
+ delete(['a','b','c','b'], 'b')
+ Would return: ['a','c']
+
+ delete({'a'=>1,'b'=>2,'c'=>3}, 'b')
+ Would return: {'a'=>1,'c'=>3}
+
+ delete({'a'=>1,'b'=>2,'c'=>3}, ['b','c'])
+ Would return: {'a'=>1}
+
+ delete('abracadabra', 'bra')
+ Would return: 'acada'
+ EOS
+ ) do |arguments|
+
+ if (arguments.size != 2) then
+ raise(Puppet::ParseError, "delete(): Wrong number of arguments "+
+ "given #{arguments.size} for 2.")
+ end
+
+ collection = arguments[0].dup
+ Array(arguments[1]).each do |item|
+ case collection
+ when Array, Hash
+ collection.delete item
+ when String
+ collection.gsub! item, ''
+ else
+ raise(TypeError, "delete(): First argument must be an Array, " +
+ "String, or Hash. Given an argument of class #{collection.class}.")
+ end
+ end
+ collection
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# delete_at.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:delete_at, :type => :rvalue, :doc => <<-EOS
+Deletes a determined indexed value from an array.
+
+*Examples:*
+
+ delete_at(['a','b','c'], 1)
+
+Would return: ['a','c']
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "delete_at(): Wrong number of arguments " +
+ "given (#{arguments.size} for 2)") if arguments.size < 2
+
+ array = arguments[0]
+
+ unless array.is_a?(Array)
+ raise(Puppet::ParseError, 'delete_at(): Requires array to work with')
+ end
+
+ index = arguments[1]
+
+ if index.is_a?(String) and not index.match(/^\d+$/)
+ raise(Puppet::ParseError, 'delete_at(): You must provide ' +
+ 'non-negative numeric index')
+ end
+
+ result = array.clone
+
+ # Numbers in Puppet are often string-encoded which is troublesome ...
+ index = index.to_i
+
+ if index > result.size - 1 # First element is at index 0 is it not?
+ raise(Puppet::ParseError, 'delete_at(): Given index ' +
+ 'exceeds size of array given')
+ end
+
+ result.delete_at(index) # We ignore the element that got deleted ...
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:delete_undef_values, :type => :rvalue, :doc => <<-EOS
+Returns a copy of input hash or array with all undefs deleted.
+
+*Examples:*
+
+ $hash = delete_undef_values({a=>'A', b=>'', c=>undef, d => false})
+
+Would return: {a => 'A', b => '', d => false}
+
+ $array = delete_undef_values(['A','',undef,false])
+
+Would return: ['A','',false]
+
+ EOS
+ ) do |args|
+
+ raise(Puppet::ParseError,
+ "delete_undef_values(): Wrong number of arguments given " +
+ "(#{args.size})") if args.size < 1
+
+ unless args[0].is_a? Array or args[0].is_a? Hash
+ raise(Puppet::ParseError,
+ "delete_undef_values(): expected an array or hash, got #{args[0]} type #{args[0].class} ")
+ end
+ result = args[0].dup
+ if result.is_a?(Hash)
+ result.delete_if {|key, val| val.equal? :undef}
+ elsif result.is_a?(Array)
+ result.delete :undef
+ end
+ result
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:delete_values, :type => :rvalue, :doc => <<-EOS
+Deletes all instances of a given value from a hash.
+
+*Examples:*
+
+ delete_values({'a'=>'A','b'=>'B','c'=>'C','B'=>'D'}, 'B')
+
+Would return: {'a'=>'A','c'=>'C','B'=>'D'}
+
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError,
+ "delete_values(): Wrong number of arguments given " +
+ "(#{arguments.size} of 2)") if arguments.size != 2
+
+ hash, item = arguments
+
+ if not hash.is_a?(Hash)
+ raise(TypeError, "delete_values(): First argument must be a Hash. " + \
+ "Given an argument of class #{hash.class}.")
+ end
+ hash.dup.delete_if { |key, val| item == val }
+ end
+end
--- /dev/null
+#
+# difference.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:difference, :type => :rvalue, :doc => <<-EOS
+This function returns the difference between two arrays.
+The returned array is a copy of the original array, removing any items that
+also appear in the second array.
+
+*Examples:*
+
+ difference(["a","b","c"],["b","c","d"])
+
+Would return: ["a"]
+ EOS
+ ) do |arguments|
+
+ # Two arguments are required
+ raise(Puppet::ParseError, "difference(): Wrong number of arguments " +
+ "given (#{arguments.size} for 2)") if arguments.size != 2
+
+ first = arguments[0]
+ second = arguments[1]
+
+ unless first.is_a?(Array) && second.is_a?(Array)
+ raise(Puppet::ParseError, 'difference(): Requires 2 arrays')
+ end
+
+ result = first - second
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:dirname, :type => :rvalue, :doc => <<-EOS
+ Returns the dirname of a path.
+ EOS
+ ) do |arguments|
+
+ if arguments.size < 1 then
+ raise(Puppet::ParseError, "dirname(): No arguments given")
+ end
+ if arguments.size > 1 then
+ raise(Puppet::ParseError, "dirname(): Too many arguments given (#{arguments.size})")
+ end
+ unless arguments[0].is_a?(String)
+ raise(Puppet::ParseError, 'dirname(): Requires string as argument')
+ end
+
+ return File.dirname(arguments[0])
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# downcase.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:downcase, :type => :rvalue, :doc => <<-EOS
+Converts the case of a string or all strings in an array to lower case.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "downcase(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'downcase(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ if value.is_a?(Array)
+ # Numbers in Puppet are often string-encoded which is troublesome ...
+ result = value.collect { |i| i.is_a?(String) ? i.downcase : i }
+ else
+ result = value.downcase
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# empty.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:empty, :type => :rvalue, :doc => <<-EOS
+Returns true if the variable is empty.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "empty(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(Hash) || value.is_a?(String)
+ raise(Puppet::ParseError, 'empty(): Requires either ' +
+ 'array, hash or string to work with')
+ end
+
+ result = value.empty?
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# ensure_packages.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:ensure_packages, :type => :statement, :doc => <<-EOS
+Takes a list of packages and only installs them if they don't already exist.
+It optionally takes a hash as a second parameter that will be passed as the
+third argument to the ensure_resource() function.
+ EOS
+ ) do |arguments|
+
+ if arguments.size > 2 or arguments.size == 0
+ raise(Puppet::ParseError, "ensure_packages(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1 or 2)")
+ elsif arguments.size == 2 and !arguments[1].is_a?(Hash)
+ raise(Puppet::ParseError, 'ensure_packages(): Requires second argument to be a Hash')
+ end
+
+ packages = Array(arguments[0])
+
+ if arguments[1]
+ defaults = { 'ensure' => 'present' }.merge(arguments[1])
+ else
+ defaults = { 'ensure' => 'present' }
+ end
+
+ Puppet::Parser::Functions.function(:ensure_resource)
+ packages.each { |package_name|
+ function_ensure_resource(['package', package_name, defaults ])
+ }
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+# Test whether a given class or definition is defined
+require 'puppet/parser/functions'
+
+Puppet::Parser::Functions.newfunction(:ensure_resource,
+ :type => :statement,
+ :doc => <<-'ENDOFDOC'
+Takes a resource type, title, and a list of attributes that describe a
+resource.
+
+ user { 'dan':
+ ensure => present,
+ }
+
+This example only creates the resource if it does not already exist:
+
+ ensure_resource('user', 'dan', {'ensure' => 'present' })
+
+If the resource already exists but does not match the specified parameters,
+this function will attempt to recreate the resource leading to a duplicate
+resource definition error.
+
+An array of resources can also be passed in and each will be created with
+the type and parameters specified if it doesn't already exist.
+
+ ensure_resource('user', ['dan','alex'], {'ensure' => 'present'})
+
+ENDOFDOC
+) do |vals|
+ type, title, params = vals
+ raise(ArgumentError, 'Must specify a type') unless type
+ raise(ArgumentError, 'Must specify a title') unless title
+ params ||= {}
+
+ items = [title].flatten
+
+ items.each do |item|
+ Puppet::Parser::Functions.function(:defined_with_params)
+ if function_defined_with_params(["#{type}[#{item}]", params])
+ Puppet.debug("Resource #{type}[#{item}] with params #{params} not created because it already exists")
+ else
+ Puppet.debug("Create new resource #{type}[#{item}] with params #{params}")
+ Puppet::Parser::Functions.function(:create_resources)
+ function_create_resources([type.capitalize, { item => params }])
+ end
+ end
+end
--- /dev/null
+#
+# flatten.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:flatten, :type => :rvalue, :doc => <<-EOS
+This function flattens any deeply nested arrays and returns a single flat array
+as a result.
+
+*Examples:*
+
+ flatten(['a', ['b', ['c']]])
+
+Would return: ['a','b','c']
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "flatten(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size != 1
+
+ array = arguments[0]
+
+ unless array.is_a?(Array)
+ raise(Puppet::ParseError, 'flatten(): Requires array to work with')
+ end
+
+ result = array.flatten
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:floor, :type => :rvalue, :doc => <<-EOS
+ Returns the largest integer less or equal to the argument.
+ Takes a single numeric value as an argument.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "floor(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size != 1
+
+ begin
+ arg = Float(arguments[0])
+ rescue TypeError, ArgumentError => e
+ raise(Puppet::ParseError, "floor(): Wrong argument type " +
+ "given (#{arguments[0]} for Numeric)")
+ end
+
+ raise(Puppet::ParseError, "floor(): Wrong argument type " +
+ "given (#{arg.class} for Numeric)") if arg.is_a?(Numeric) == false
+
+ arg.floor
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+Puppet::Parser::Functions::newfunction(
+ :fqdn_rand_string,
+ :arity => -2,
+ :type => :rvalue,
+ :doc => "Usage: `fqdn_rand_string(LENGTH, [CHARSET], [SEED])`. LENGTH is
+ required and must be a positive integer. CHARSET is optional and may be
+ `undef` or a string. SEED is optional and may be any number or string.
+
+ Generates a random string LENGTH characters long using the character set
+ provided by CHARSET, combining the `$fqdn` fact and the value of SEED for
+ repeatable randomness. (That is, each node will get a different random
+ string from this function, but a given node's result will be the same every
+ time unless its hostname changes.) Adding a SEED can be useful if you need
+ more than one unrelated string. CHARSET will default to alphanumeric if
+ `undef` or an empty string.") do |args|
+ raise(ArgumentError, "fqdn_rand_string(): wrong number of arguments (0 for 1)") if args.size == 0
+ Puppet::Parser::Functions.function('is_integer')
+ raise(ArgumentError, "fqdn_rand_base64(): first argument must be a positive integer") unless function_is_integer([args[0]]) and args[0].to_i > 0
+ raise(ArgumentError, "fqdn_rand_base64(): second argument must be undef or a string") unless args[1].nil? or args[1].is_a? String
+
+ Puppet::Parser::Functions.function('fqdn_rand')
+
+ length = args.shift.to_i
+ charset = args.shift.to_s.chars.to_a
+
+ charset = (0..9).map { |i| i.to_s } + ('A'..'Z').to_a + ('a'..'z').to_a if charset.empty?
+
+ rand_string = ''
+ for current in 1..length
+ rand_string << charset[function_fqdn_rand([charset.size, (args + [current.to_s]).join(':')]).to_i]
+ end
+
+ rand_string
+end
--- /dev/null
+#
+# fqdn_rotate.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:fqdn_rotate, :type => :rvalue, :doc => <<-EOS
+Rotates an array a random number of times based on a nodes fqdn.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "fqdn_rotate(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+ require 'digest/md5'
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'fqdn_rotate(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ result = value.clone
+
+ string = value.is_a?(String) ? true : false
+
+ # Check whether it makes sense to rotate ...
+ return result if result.size <= 1
+
+ # We turn any string value into an array to be able to rotate ...
+ result = string ? result.split('') : result
+
+ elements = result.size
+
+ seed = Digest::MD5.hexdigest([lookupvar('::fqdn'),arguments].join(':')).hex
+ # deterministic_rand() was added in Puppet 3.2.0; reimplement if necessary
+ if Puppet::Util.respond_to?(:deterministic_rand)
+ offset = Puppet::Util.deterministic_rand(seed, elements).to_i
+ else
+ if defined?(Random) == 'constant' && Random.class == Class
+ offset = Random.new(seed).rand(elements)
+ else
+ srand(seed)
+ offset = rand(elements)
+ srand()
+ end
+ end
+ offset.times {
+ result.push result.shift
+ }
+
+ result = string ? result.join : result
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:get_module_path, :type =>:rvalue, :doc => <<-EOT
+ Returns the absolute path of the specified module for the current
+ environment.
+
+ Example:
+ $module_path = get_module_path('stdlib')
+ EOT
+ ) do |args|
+ raise(Puppet::ParseError, "get_module_path(): Wrong number of arguments, expects one") unless args.size == 1
+ if module_path = Puppet::Module.find(args[0], compiler.environment.to_s)
+ module_path.path
+ else
+ raise(Puppet::ParseError, "Could not find module #{args[0]} in environment #{compiler.environment}")
+ end
+ end
+end
--- /dev/null
+# Test whether a given class or definition is defined
+require 'puppet/parser/functions'
+
+Puppet::Parser::Functions.newfunction(:getparam,
+ :type => :rvalue,
+ :doc => <<-'ENDOFDOC'
+Takes a resource reference and name of the parameter and
+returns value of resource's parameter.
+
+*Examples:*
+
+ define example_resource($param) {
+ }
+
+ example_resource { "example_resource_instance":
+ param => "param_value"
+ }
+
+ getparam(Example_resource["example_resource_instance"], "param")
+
+Would return: param_value
+ENDOFDOC
+) do |vals|
+ reference, param = vals
+ raise(ArgumentError, 'Must specify a reference') unless reference
+ raise(ArgumentError, 'Must specify name of a parameter') unless param and param.instance_of? String
+
+ return '' if param.empty?
+
+ if resource = findresource(reference.to_s)
+ return resource[param] if resource[param]
+ end
+
+ return ''
+end
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:getvar, :type => :rvalue, :doc => <<-'ENDHEREDOC') do |args|
+ Lookup a variable in a remote namespace.
+
+ For example:
+
+ $foo = getvar('site::data::foo')
+ # Equivalent to $foo = $site::data::foo
+
+ This is useful if the namespace itself is stored in a string:
+
+ $datalocation = 'site::data'
+ $bar = getvar("${datalocation}::bar")
+ # Equivalent to $bar = $site::data::bar
+ ENDHEREDOC
+
+ unless args.length == 1
+ raise Puppet::ParseError, ("getvar(): wrong number of arguments (#{args.length}; must be 1)")
+ end
+
+ begin
+ self.lookupvar("#{args[0]}")
+ rescue Puppet::ParseError # Eat the exception if strict_variables = true is set
+ end
+
+ end
+
+end
--- /dev/null
+#
+# grep.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:grep, :type => :rvalue, :doc => <<-EOS
+This function searches through an array and returns any elements that match
+the provided regular expression.
+
+*Examples:*
+
+ grep(['aaa','bbb','ccc','aaaddd'], 'aaa')
+
+Would return:
+
+ ['aaa','aaaddd']
+ EOS
+ ) do |arguments|
+
+ if (arguments.size != 2) then
+ raise(Puppet::ParseError, "grep(): Wrong number of arguments "+
+ "given #{arguments.size} for 2")
+ end
+
+ a = arguments[0]
+ pattern = Regexp.new(arguments[1])
+
+ a.grep(pattern)
+
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# has_interface_with
+#
+
+module Puppet::Parser::Functions
+ newfunction(:has_interface_with, :type => :rvalue, :doc => <<-EOS
+Returns boolean based on kind and value:
+ * macaddress
+ * netmask
+ * ipaddress
+ * network
+
+has_interface_with("macaddress", "x:x:x:x:x:x")
+has_interface_with("ipaddress", "127.0.0.1") => true
+etc.
+
+If no "kind" is given, then the presence of the interface is checked:
+has_interface_with("lo") => true
+ EOS
+ ) do |args|
+
+ raise(Puppet::ParseError, "has_interface_with(): Wrong number of arguments " +
+ "given (#{args.size} for 1 or 2)") if args.size < 1 or args.size > 2
+
+ interfaces = lookupvar('interfaces')
+
+ # If we do not have any interfaces, then there are no requested attributes
+ return false if (interfaces == :undefined || interfaces.nil?)
+
+ interfaces = interfaces.split(',')
+
+ if args.size == 1
+ return interfaces.member?(args[0])
+ end
+
+ kind, value = args
+
+ # Bug with 3.7.1 - 3.7.3 when using future parser throws :undefined_variable
+ # https://tickets.puppetlabs.com/browse/PUP-3597
+ factval = nil
+ catch :undefined_variable do
+ factval = lookupvar(kind)
+ end
+ if factval == value
+ return true
+ end
+
+ result = false
+ interfaces.each do |iface|
+ iface.downcase!
+ factval = nil
+ begin
+ # Bug with 3.7.1 - 3.7.3 when using future parser throws :undefined_variable
+ # https://tickets.puppetlabs.com/browse/PUP-3597
+ catch :undefined_variable do
+ factval = lookupvar("#{kind}_#{iface}")
+ end
+ rescue Puppet::ParseError # Eat the exception if strict_variables = true is set
+ end
+ if value == factval
+ result = true
+ break
+ end
+ end
+
+ result
+ end
+end
--- /dev/null
+#
+# has_ip_address
+#
+
+module Puppet::Parser::Functions
+ newfunction(:has_ip_address, :type => :rvalue, :doc => <<-EOS
+Returns true if the client has the requested IP address on some interface.
+
+This function iterates through the 'interfaces' fact and checks the
+'ipaddress_IFACE' facts, performing a simple string comparison.
+ EOS
+ ) do |args|
+
+ raise(Puppet::ParseError, "has_ip_address(): Wrong number of arguments " +
+ "given (#{args.size} for 1)") if args.size != 1
+
+ Puppet::Parser::Functions.autoloader.load(:has_interface_with) \
+ unless Puppet::Parser::Functions.autoloader.loaded?(:has_interface_with)
+
+ function_has_interface_with(['ipaddress', args[0]])
+
+ end
+end
+
+# vim:sts=2 sw=2
--- /dev/null
+#
+# has_ip_network
+#
+
+module Puppet::Parser::Functions
+ newfunction(:has_ip_network, :type => :rvalue, :doc => <<-EOS
+Returns true if the client has an IP address within the requested network.
+
+This function iterates through the 'interfaces' fact and checks the
+'network_IFACE' facts, performing a simple string comparision.
+ EOS
+ ) do |args|
+
+ raise(Puppet::ParseError, "has_ip_network(): Wrong number of arguments " +
+ "given (#{args.size} for 1)") if args.size != 1
+
+ Puppet::Parser::Functions.autoloader.load(:has_interface_with) \
+ unless Puppet::Parser::Functions.autoloader.loaded?(:has_interface_with)
+
+ function_has_interface_with(['network', args[0]])
+
+ end
+end
+
+# vim:sts=2 sw=2
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:has_key, :type => :rvalue, :doc => <<-'ENDHEREDOC') do |args|
+ Determine if a hash has a certain key value.
+
+ Example:
+
+ $my_hash = {'key_one' => 'value_one'}
+ if has_key($my_hash, 'key_two') {
+ notice('we will not reach here')
+ }
+ if has_key($my_hash, 'key_one') {
+ notice('this will be printed')
+ }
+
+ ENDHEREDOC
+
+ unless args.length == 2
+ raise Puppet::ParseError, ("has_key(): wrong number of arguments (#{args.length}; must be 2)")
+ end
+ unless args[0].is_a?(Hash)
+ raise Puppet::ParseError, "has_key(): expects the first argument to be a hash, got #{args[0].inspect} which is of type #{args[0].class}"
+ end
+ args[0].has_key?(args[1])
+
+ end
+
+end
--- /dev/null
+#
+# hash.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:hash, :type => :rvalue, :doc => <<-EOS
+This function converts an array into a hash.
+
+*Examples:*
+
+ hash(['a',1,'b',2,'c',3])
+
+Would return: {'a'=>1,'b'=>2,'c'=>3}
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "hash(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ array = arguments[0]
+
+ unless array.is_a?(Array)
+ raise(Puppet::ParseError, 'hash(): Requires array to work with')
+ end
+
+ result = {}
+
+ begin
+ # This is to make it compatible with older version of Ruby ...
+ array = array.flatten
+ result = Hash[*array]
+ rescue Exception
+ raise(Puppet::ParseError, 'hash(): Unable to compute ' +
+ 'hash from array given')
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# intersection.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:intersection, :type => :rvalue, :doc => <<-EOS
+This function returns an array an intersection of two.
+
+*Examples:*
+
+ intersection(["a","b","c"],["b","c","d"])
+
+Would return: ["b","c"]
+ EOS
+ ) do |arguments|
+
+ # Two arguments are required
+ raise(Puppet::ParseError, "intersection(): Wrong number of arguments " +
+ "given (#{arguments.size} for 2)") if arguments.size != 2
+
+ first = arguments[0]
+ second = arguments[1]
+
+ unless first.is_a?(Array) && second.is_a?(Array)
+ raise(Puppet::ParseError, 'intersection(): Requires 2 arrays')
+ end
+
+ result = first & second
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# is_array.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:is_array, :type => :rvalue, :doc => <<-EOS
+Returns true if the variable passed to this function is an array.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "is_array(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ type = arguments[0]
+
+ result = type.is_a?(Array)
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# is_bool.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:is_bool, :type => :rvalue, :doc => <<-EOS
+Returns true if the variable passed to this function is a boolean.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "is_bool(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size != 1
+
+ type = arguments[0]
+
+ result = type.is_a?(TrueClass) || type.is_a?(FalseClass)
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# is_domain_name.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:is_domain_name, :type => :rvalue, :doc => <<-EOS
+Returns true if the string passed to this function is a syntactically correct domain name.
+ EOS
+ ) do |arguments|
+
+ if (arguments.size != 1) then
+ raise(Puppet::ParseError, "is_domain_name(): Wrong number of arguments "+
+ "given #{arguments.size} for 1")
+ end
+
+ # Only allow string types
+ return false unless arguments[0].is_a?(String)
+
+ domain = arguments[0].dup
+
+ # Limits (rfc1035, 3.1)
+ domain_max_length=255
+ label_min_length=1
+ label_max_length=63
+
+ # Allow ".", it is the top level domain
+ return true if domain == '.'
+
+ # Remove the final dot, if present.
+ domain.chomp!('.')
+
+ # Check the whole domain
+ return false if domain.empty?
+ return false if domain.length > domain_max_length
+
+ # The top level domain must be alphabetic if there are multiple labels.
+ # See rfc1123, 2.1
+ return false if domain.include? '.' and not /\.[A-Za-z]+$/.match(domain)
+
+ # Check each label in the domain
+ labels = domain.split('.')
+ vlabels = labels.each do |label|
+ break if label.length < label_min_length
+ break if label.length > label_max_length
+ break if label[-1..-1] == '-'
+ break if label[0..0] == '-'
+ break unless /^[a-z\d-]+$/i.match(label)
+ end
+ return vlabels == labels
+
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# is_float.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:is_float, :type => :rvalue, :doc => <<-EOS
+Returns true if the variable passed to this function is a float.
+ EOS
+ ) do |arguments|
+
+ if (arguments.size != 1) then
+ raise(Puppet::ParseError, "is_float(): Wrong number of arguments "+
+ "given #{arguments.size} for 1")
+ end
+
+ value = arguments[0]
+
+ # Only allow Numeric or String types
+ return false unless value.is_a?(Numeric) or value.is_a?(String)
+
+ if value != value.to_f.to_s and !value.is_a? Float then
+ return false
+ else
+ return true
+ end
+
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# is_function_available.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:is_function_available, :type => :rvalue, :doc => <<-EOS
+This function accepts a string as an argument, determines whether the
+Puppet runtime has access to a function by that name. It returns a
+true if the function exists, false if not.
+ EOS
+ ) do |arguments|
+
+ if (arguments.size != 1) then
+ raise(Puppet::ParseError, "is_function_available?(): Wrong number of arguments "+
+ "given #{arguments.size} for 1")
+ end
+
+ # Only allow String types
+ return false unless arguments[0].is_a?(String)
+
+ function = Puppet::Parser::Functions.function(arguments[0].to_sym)
+ function.is_a?(String) and not function.empty?
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# is_hash.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:is_hash, :type => :rvalue, :doc => <<-EOS
+Returns true if the variable passed to this function is a hash.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "is_hash(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size != 1
+
+ type = arguments[0]
+
+ result = type.is_a?(Hash)
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# is_integer.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:is_integer, :type => :rvalue, :doc => <<-EOS
+Returns true if the variable passed to this function is an Integer or
+a decimal (base 10) integer in String form. The string may
+start with a '-' (minus). A value of '0' is allowed, but a leading '0' digit may not
+be followed by other digits as this indicates that the value is octal (base 8).
+
+If given any other argument `false` is returned.
+ EOS
+ ) do |arguments|
+
+ if (arguments.size != 1) then
+ raise(Puppet::ParseError, "is_integer(): Wrong number of arguments "+
+ "given #{arguments.size} for 1")
+ end
+
+ value = arguments[0]
+
+ # Regex is taken from the lexer of puppet
+ # puppet/pops/parser/lexer.rb but modified to match also
+ # negative values and disallow numbers prefixed with multiple
+ # 0's
+ #
+ # TODO these parameter should be a constant but I'm not sure
+ # if there is no risk to declare it inside of the module
+ # Puppet::Parser::Functions
+
+ # Integer numbers like
+ # -1234568981273
+ # 47291
+ numeric = %r{^-?(?:(?:[1-9]\d*)|0)$}
+
+ if value.is_a? Integer or (value.is_a? String and value.match numeric)
+ return true
+ else
+ return false
+ end
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# is_ip_address.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:is_ip_address, :type => :rvalue, :doc => <<-EOS
+Returns true if the string passed to this function is a valid IP address.
+ EOS
+ ) do |arguments|
+
+ require 'ipaddr'
+
+ if (arguments.size != 1) then
+ raise(Puppet::ParseError, "is_ip_address(): Wrong number of arguments "+
+ "given #{arguments.size} for 1")
+ end
+
+ begin
+ ip = IPAddr.new(arguments[0])
+ rescue ArgumentError
+ return false
+ end
+
+ if ip.ipv4? or ip.ipv6? then
+ return true
+ else
+ return false
+ end
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# is_mac_address.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:is_mac_address, :type => :rvalue, :doc => <<-EOS
+Returns true if the string passed to this function is a valid mac address.
+ EOS
+ ) do |arguments|
+
+ if (arguments.size != 1) then
+ raise(Puppet::ParseError, "is_mac_address(): Wrong number of arguments "+
+ "given #{arguments.size} for 1")
+ end
+
+ mac = arguments[0]
+
+ if /^[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}$/.match(mac) then
+ return true
+ else
+ return false
+ end
+
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# is_numeric.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:is_numeric, :type => :rvalue, :doc => <<-EOS
+Returns true if the given argument is a Numeric (Integer or Float),
+or a String containing either a valid integer in decimal base 10 form, or
+a valid floating point string representation.
+
+The function recognizes only decimal (base 10) integers and float but not
+integers in hex (base 16) or octal (base 8) form.
+
+The string representation may start with a '-' (minus). If a decimal '.' is used,
+it must be followed by at least one digit.
+
+Valid examples:
+
+ 77435
+ 10e-12
+ -8475
+ 0.2343
+ -23.561e3
+ EOS
+ ) do |arguments|
+
+ if (arguments.size != 1) then
+ raise(Puppet::ParseError, "is_numeric(): Wrong number of arguments "+
+ "given #{arguments.size} for 1")
+ end
+
+ value = arguments[0]
+
+ # Regex is taken from the lexer of puppet
+ # puppet/pops/parser/lexer.rb but modified to match also
+ # negative values and disallow invalid octal numbers or
+ # numbers prefixed with multiple 0's (except in hex numbers)
+ #
+ # TODO these parameters should be constants but I'm not sure
+ # if there is no risk to declare them inside of the module
+ # Puppet::Parser::Functions
+
+ # TODO decide if this should be used
+ # HEX numbers like
+ # 0xaa230F
+ # 0X1234009C
+ # 0x0012
+ # -12FcD
+ #numeric_hex = %r{^-?0[xX][0-9A-Fa-f]+$}
+
+ # TODO decide if this should be used
+ # OCTAL numbers like
+ # 01234567
+ # -045372
+ #numeric_oct = %r{^-?0[1-7][0-7]*$}
+
+ # Integer/Float numbers like
+ # -0.1234568981273
+ # 47291
+ # 42.12345e-12
+ numeric = %r{^-?(?:(?:[1-9]\d*)|0)(?:\.\d+)?(?:[eE]-?\d+)?$}
+
+ if value.is_a? Numeric or (value.is_a? String and (
+ value.match(numeric) #or
+ # value.match(numeric_hex) or
+ # value.match(numeric_oct)
+ ))
+ return true
+ else
+ return false
+ end
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# is_string.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:is_string, :type => :rvalue, :doc => <<-EOS
+Returns true if the variable passed to this function is a string.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "is_string(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ type = arguments[0]
+
+ result = type.is_a?(String)
+
+ if result and (type == type.to_f.to_s or type == type.to_i.to_s) then
+ return false
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# join.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:join, :type => :rvalue, :doc => <<-EOS
+This function joins an array into a string using a separator.
+
+*Examples:*
+
+ join(['a','b','c'], ",")
+
+Would result in: "a,b,c"
+ EOS
+ ) do |arguments|
+
+ # Technically we support two arguments but only first is mandatory ...
+ raise(Puppet::ParseError, "join(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ array = arguments[0]
+
+ unless array.is_a?(Array)
+ raise(Puppet::ParseError, 'join(): Requires array to work with')
+ end
+
+ suffix = arguments[1] if arguments[1]
+
+ if suffix
+ unless suffix.is_a?(String)
+ raise(Puppet::ParseError, 'join(): Requires string to work with')
+ end
+ end
+
+ result = suffix ? array.join(suffix) : array.join
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# join.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:join_keys_to_values, :type => :rvalue, :doc => <<-EOS
+This function joins each key of a hash to that key's corresponding value with a
+separator. Keys and values are cast to strings. The return value is an array in
+which each element is one joined key/value pair.
+
+*Examples:*
+
+ join_keys_to_values({'a'=>1,'b'=>2}, " is ")
+
+Would result in: ["a is 1","b is 2"]
+ EOS
+ ) do |arguments|
+
+ # Validate the number of arguments.
+ if arguments.size != 2
+ raise(Puppet::ParseError, "join_keys_to_values(): Takes exactly two " +
+ "arguments, but #{arguments.size} given.")
+ end
+
+ # Validate the first argument.
+ hash = arguments[0]
+ if not hash.is_a?(Hash)
+ raise(TypeError, "join_keys_to_values(): The first argument must be a " +
+ "hash, but a #{hash.class} was given.")
+ end
+
+ # Validate the second argument.
+ separator = arguments[1]
+ if not separator.is_a?(String)
+ raise(TypeError, "join_keys_to_values(): The second argument must be a " +
+ "string, but a #{separator.class} was given.")
+ end
+
+ # Join the keys to their values.
+ hash.map do |k,v|
+ String(k) + separator + String(v)
+ end
+
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# keys.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:keys, :type => :rvalue, :doc => <<-EOS
+Returns the keys of a hash as an array.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "keys(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ hash = arguments[0]
+
+ unless hash.is_a?(Hash)
+ raise(Puppet::ParseError, 'keys(): Requires hash to work with')
+ end
+
+ result = hash.keys
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:loadyaml, :type => :rvalue, :doc => <<-'ENDHEREDOC') do |args|
+ Load a YAML file containing an array, string, or hash, and return the data
+ in the corresponding native data type.
+
+ For example:
+
+ $myhash = loadyaml('/etc/puppet/data/myhash.yaml')
+ ENDHEREDOC
+
+ unless args.length == 1
+ raise Puppet::ParseError, ("loadyaml(): wrong number of arguments (#{args.length}; must be 1)")
+ end
+
+ YAML.load_file(args[0])
+
+ end
+
+end
--- /dev/null
+#
+# lstrip.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:lstrip, :type => :rvalue, :doc => <<-EOS
+Strips leading spaces to the left of a string.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "lstrip(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'lstrip(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ if value.is_a?(Array)
+ # Numbers in Puppet are often string-encoded which is troublesome ...
+ result = value.collect { |i| i.is_a?(String) ? i.lstrip : i }
+ else
+ result = value.lstrip
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:max, :type => :rvalue, :doc => <<-EOS
+ Returns the highest value of all arguments.
+ Requires at least one argument.
+ EOS
+ ) do |args|
+
+ raise(Puppet::ParseError, "max(): Wrong number of arguments " +
+ "need at least one") if args.size == 0
+
+ # Sometimes we get numbers as numerics and sometimes as strings.
+ # We try to compare them as numbers when possible
+ return args.max do |a,b|
+ if a.to_s =~ /\A-?\d+(.\d+)?\z/ and b.to_s =~ /\A-?\d+(.\d+)?\z/ then
+ a.to_f <=> b.to_f
+ else
+ a.to_s <=> b.to_s
+ end
+ end
+ end
+end
--- /dev/null
+#
+# member.rb
+#
+
+# TODO(Krzysztof Wilczynski): We need to add support for regular expression ...
+# TODO(Krzysztof Wilczynski): Support for strings and hashes too ...
+
+module Puppet::Parser::Functions
+ newfunction(:member, :type => :rvalue, :doc => <<-EOS
+This function determines if a variable is a member of an array.
+The variable can be a string, fixnum, or array.
+
+*Examples:*
+
+ member(['a','b'], 'b')
+
+Would return: true
+
+ member(['a', 'b', 'c'], ['a', 'b'])
+
+would return: true
+
+ member(['a','b'], 'c')
+
+Would return: false
+
+ member(['a', 'b', 'c'], ['d', 'b'])
+
+would return: false
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "member(): Wrong number of arguments " +
+ "given (#{arguments.size} for 2)") if arguments.size < 2
+
+ array = arguments[0]
+
+ unless array.is_a?(Array)
+ raise(Puppet::ParseError, 'member(): Requires array to work with')
+ end
+
+ unless arguments[1].is_a? String or arguments[1].is_a? Fixnum or arguments[1].is_a? Array
+ raise(Puppet::ParseError, 'member(): Item to search for must be a string, fixnum, or array')
+ end
+
+ if arguments[1].is_a? String or arguments[1].is_a? Fixnum
+ item = Array(arguments[1])
+ else
+ item = arguments[1]
+ end
+
+
+ raise(Puppet::ParseError, 'member(): You must provide item ' +
+ 'to search for within array given') if item.respond_to?('empty?') && item.empty?
+
+ result = (item - array).empty?
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:merge, :type => :rvalue, :doc => <<-'ENDHEREDOC') do |args|
+ Merges two or more hashes together and returns the resulting hash.
+
+ For example:
+
+ $hash1 = {'one' => 1, 'two', => 2}
+ $hash2 = {'two' => 'dos', 'three', => 'tres'}
+ $merged_hash = merge($hash1, $hash2)
+ # The resulting hash is equivalent to:
+ # $merged_hash = {'one' => 1, 'two' => 'dos', 'three' => 'tres'}
+
+ When there is a duplicate key, the key in the rightmost hash will "win."
+
+ ENDHEREDOC
+
+ if args.length < 2
+ raise Puppet::ParseError, ("merge(): wrong number of arguments (#{args.length}; must be at least 2)")
+ end
+
+ # The hash we accumulate into
+ accumulator = Hash.new
+ # Merge into the accumulator hash
+ args.each do |arg|
+ next if arg.is_a? String and arg.empty? # empty string is synonym for puppet's undef
+ unless arg.is_a?(Hash)
+ raise Puppet::ParseError, "merge: unexpected argument type #{arg.class}, only expects hash arguments"
+ end
+ accumulator.merge!(arg)
+ end
+ # Return the fully merged hash
+ accumulator
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:min, :type => :rvalue, :doc => <<-EOS
+ Returns the lowest value of all arguments.
+ Requires at least one argument.
+ EOS
+ ) do |args|
+
+ raise(Puppet::ParseError, "min(): Wrong number of arguments " +
+ "need at least one") if args.size == 0
+
+ # Sometimes we get numbers as numerics and sometimes as strings.
+ # We try to compare them as numbers when possible
+ return args.min do |a,b|
+ if a.to_s =~ /\A^-?\d+(.\d+)?\z/ and b.to_s =~ /\A-?\d+(.\d+)?\z/ then
+ a.to_f <=> b.to_f
+ else
+ a.to_s <=> b.to_s
+ end
+ end
+ end
+end
--- /dev/null
+#
+# num2bool.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:num2bool, :type => :rvalue, :doc => <<-EOS
+This function converts a number or a string representation of a number into a
+true boolean. Zero or anything non-numeric becomes false. Numbers higher then 0
+become true.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "num2bool(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size != 1
+
+ number = arguments[0]
+
+ case number
+ when Numeric
+ # Yay, it's a number
+ when String
+ begin
+ number = Float(number)
+ rescue ArgumentError => ex
+ raise(Puppet::ParseError, "num2bool(): '#{number}' does not look like a number: #{ex.message}")
+ end
+ else
+ begin
+ number = number.to_s
+ rescue NoMethodError => ex
+ raise(Puppet::ParseError, "num2bool(): Unable to parse argument: #{ex.message}")
+ end
+ end
+
+ # Truncate Floats
+ number = number.to_i
+
+ # Return true for any positive number and false otherwise
+ return number > 0
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# parsejson.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:parsejson, :type => :rvalue, :doc => <<-EOS
+This function accepts JSON as a string and converts into the correct Puppet
+structure.
+ EOS
+ ) do |arguments|
+
+ if (arguments.size != 1) then
+ raise(Puppet::ParseError, "parsejson(): Wrong number of arguments "+
+ "given #{arguments.size} for 1")
+ end
+
+ json = arguments[0]
+
+ # PSON is natively available in puppet
+ PSON.load(json)
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# parseyaml.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:parseyaml, :type => :rvalue, :doc => <<-EOS
+This function accepts YAML as a string and converts it into the correct
+Puppet structure.
+ EOS
+ ) do |arguments|
+
+ if (arguments.size != 1) then
+ raise(Puppet::ParseError, "parseyaml(): Wrong number of arguments "+
+ "given #{arguments.size} for 1")
+ end
+
+ require 'yaml'
+
+ YAML::load(arguments[0])
+
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:pick, :type => :rvalue, :doc => <<-EOS
+
+This function is similar to a coalesce function in SQL in that it will return
+the first value in a list of values that is not undefined or an empty string
+(two things in Puppet that will return a boolean false value). Typically,
+this function is used to check for a value in the Puppet Dashboard/Enterprise
+Console, and failover to a default value like the following:
+
+ $real_jenkins_version = pick($::jenkins_version, '1.449')
+
+The value of $real_jenkins_version will first look for a top-scope variable
+called 'jenkins_version' (note that parameters set in the Puppet Dashboard/
+Enterprise Console are brought into Puppet as top-scope variables), and,
+failing that, will use a default value of 1.449.
+
+EOS
+) do |args|
+ args = args.compact
+ args.delete(:undef)
+ args.delete(:undefined)
+ args.delete("")
+ if args[0].to_s.empty? then
+ fail Puppet::ParseError, "pick(): must receive at least one non empty value"
+ else
+ return args[0]
+ end
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:pick_default, :type => :rvalue, :doc => <<-EOS
+
+This function is similar to a coalesce function in SQL in that it will return
+the first value in a list of values that is not undefined or an empty string
+(two things in Puppet that will return a boolean false value). If no value is
+found, it will return the last argument.
+
+Typically, this function is used to check for a value in the Puppet
+Dashboard/Enterprise Console, and failover to a default value like the
+following:
+
+ $real_jenkins_version = pick_default($::jenkins_version, '1.449')
+
+The value of $real_jenkins_version will first look for a top-scope variable
+called 'jenkins_version' (note that parameters set in the Puppet Dashboard/
+Enterprise Console are brought into Puppet as top-scope variables), and,
+failing that, will use a default value of 1.449.
+
+Note that, contrary to the pick() function, the pick_default does not fail if
+all arguments are empty. This allows pick_default to use an empty value as
+default.
+
+EOS
+) do |args|
+ fail "Must receive at least one argument." if args.empty?
+ default = args.last
+ args = args[0..-2].compact
+ args.delete(:undef)
+ args.delete(:undefined)
+ args.delete("")
+ args << default
+ return args[0]
+ end
+end
--- /dev/null
+#
+# prefix.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:prefix, :type => :rvalue, :doc => <<-EOS
+This function applies a prefix to all elements in an array or a hash.
+
+*Examples:*
+
+ prefix(['a','b','c'], 'p')
+
+Will return: ['pa','pb','pc']
+ EOS
+ ) do |arguments|
+
+ # Technically we support two arguments but only first is mandatory ...
+ raise(Puppet::ParseError, "prefix(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ enumerable = arguments[0]
+
+ unless enumerable.is_a?(Array) or enumerable.is_a?(Hash)
+ raise Puppet::ParseError, "prefix(): expected first argument to be an Array or a Hash, got #{enumerable.inspect}"
+ end
+
+ prefix = arguments[1] if arguments[1]
+
+ if prefix
+ unless prefix.is_a?(String)
+ raise Puppet::ParseError, "prefix(): expected second argument to be a String, got #{prefix.inspect}"
+ end
+ end
+
+ if enumerable.is_a?(Array)
+ # Turn everything into string same as join would do ...
+ result = enumerable.collect do |i|
+ i = i.to_s
+ prefix ? prefix + i : i
+ end
+ else
+ result = Hash[enumerable.map do |k,v|
+ k = k.to_s
+ [ prefix ? prefix + k : k, v ]
+ end]
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# private.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:private, :doc => <<-'EOS'
+ DEPRECATED: Sets the current class or definition as private.
+ Calling the class or definition from outside the current module will fail.
+ EOS
+ ) do |args|
+ warning("private() DEPRECATED: This function will cease to function on Puppet 4; please use assert_private() before upgrading to puppet 4 for backwards-compatibility, or migrate to the new parser's typing system.")
+ if !Puppet::Parser::Functions.autoloader.loaded?(:assert_private)
+ Puppet::Parser::Functions.autoloader.load(:assert_private)
+ end
+ function_assert_private([(args[0] unless args.size < 1)])
+ end
+end
--- /dev/null
+Puppet::Parser::Functions::newfunction(
+ :pw_hash,
+ :type => :rvalue,
+ :arity => 3,
+ :doc => "Hashes a password using the crypt function. Provides a hash
+ usable on most POSIX systems.
+
+ The first argument to this function is the password to hash. If it is
+ undef or an empty string, this function returns undef.
+
+ The second argument to this function is which type of hash to use. It
+ will be converted into the appropriate crypt(3) hash specifier. Valid
+ hash types are:
+
+ |Hash type |Specifier|
+ |---------------------|---------|
+ |MD5 |1 |
+ |SHA-256 |5 |
+ |SHA-512 (recommended)|6 |
+
+ The third argument to this function is the salt to use.
+
+ Note: this uses the Puppet Master's implementation of crypt(3). If your
+ environment contains several different operating systems, ensure that they
+ are compatible before using this function.") do |args|
+ raise ArgumentError, "pw_hash(): wrong number of arguments (#{args.size} for 3)" if args.size != 3
+ raise ArgumentError, "pw_hash(): first argument must be a string" unless args[0].is_a? String or args[0].nil?
+ raise ArgumentError, "pw_hash(): second argument must be a string" unless args[1].is_a? String
+ hashes = { 'md5' => '1',
+ 'sha-256' => '5',
+ 'sha-512' => '6' }
+ hash_type = hashes[args[1].downcase]
+ raise ArgumentError, "pw_hash(): #{args[1]} is not a valid hash type" if hash_type.nil?
+ raise ArgumentError, "pw_hash(): third argument must be a string" unless args[2].is_a? String
+ raise ArgumentError, "pw_hash(): third argument must not be empty" if args[2].empty?
+ raise ArgumentError, "pw_hash(): characters in salt must be in the set [a-zA-Z0-9./]" unless args[2].match(/\A[a-zA-Z0-9.\/]+\z/)
+
+ password = args[0]
+ return nil if password.nil? or password.empty?
+
+ # handle weak implementations of String#crypt
+ if 'test'.crypt('$1$1') != '$1$1$Bp8CU9Oujr9SSEw53WV6G.'
+ # JRuby < 1.7.17
+ if RUBY_PLATFORM == 'java'
+ # override String#crypt for password variable
+ def password.crypt(salt)
+ # puppetserver bundles Apache Commons Codec
+ org.apache.commons.codec.digest.Crypt.crypt(self.to_java_bytes, salt)
+ end
+ else
+ # MS Windows and other systems that don't support enhanced salts
+ raise Puppet::ParseError, 'system does not support enhanced salts'
+ end
+ end
+ password.crypt("$#{hash_type}$#{args[2]}")
+end
--- /dev/null
+#
+# range.rb
+#
+
+# TODO(Krzysztof Wilczynski): We probably need to approach numeric values differently ...
+
+module Puppet::Parser::Functions
+ newfunction(:range, :type => :rvalue, :doc => <<-EOS
+When given range in the form of (start, stop) it will extrapolate a range as
+an array.
+
+*Examples:*
+
+ range("0", "9")
+
+Will return: [0,1,2,3,4,5,6,7,8,9]
+
+ range("00", "09")
+
+Will return: [0,1,2,3,4,5,6,7,8,9] (Zero padded strings are converted to
+integers automatically)
+
+ range("a", "c")
+
+Will return: ["a","b","c"]
+
+ range("host01", "host10")
+
+Will return: ["host01", "host02", ..., "host09", "host10"]
+
+Passing a third argument will cause the generated range to step by that
+interval, e.g.
+
+ range("0", "9", "2")
+
+Will return: [0,2,4,6,8]
+ EOS
+ ) do |arguments|
+
+ # We support more than one argument but at least one is mandatory ...
+ raise(Puppet::ParseError, "range(): Wrong number of " +
+ "arguments given (#{arguments.size} for 1)") if arguments.size < 1
+
+ if arguments.size > 1
+ start = arguments[0]
+ stop = arguments[1]
+ step = arguments[2].nil? ? 1 : arguments[2].to_i.abs
+
+ type = '..' # We select simplest type for Range available in Ruby ...
+
+ elsif arguments.size > 0
+ value = arguments[0]
+
+ if m = value.match(/^(\w+)(\.\.\.?|\-)(\w+)$/)
+ start = m[1]
+ stop = m[3]
+
+ type = m[2]
+
+ elsif value.match(/^.+$/)
+ raise(Puppet::ParseError, 'range(): Unable to compute range ' +
+ 'from the value given')
+ else
+ raise(Puppet::ParseError, 'range(): Unknown format of range given')
+ end
+ end
+
+ # Check whether we have integer value if so then make it so ...
+ if start.to_s.match(/^\d+$/)
+ start = start.to_i
+ stop = stop.to_i
+ else
+ start = start.to_s
+ stop = stop.to_s
+ end
+
+ range = case type
+ when /^(\.\.|\-)$/ then (start .. stop)
+ when /^(\.\.\.)$/ then (start ... stop) # Exclusive of last element ...
+ end
+
+ result = range.step(step).collect { |i| i } # Get them all ... Pokemon ...
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# reject.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:reject, :type => :rvalue, :doc => <<-EOS) do |args|
+This function searches through an array and rejects all elements that match
+the provided regular expression.
+
+*Examples:*
+
+ reject(['aaa','bbb','ccc','aaaddd'], 'aaa')
+
+Would return:
+
+ ['bbb','ccc']
+EOS
+
+ if (args.size != 2)
+ raise Puppet::ParseError,
+ "reject(): Wrong number of arguments given #{args.size} for 2"
+ end
+
+ ary = args[0]
+ pattern = Regexp.new(args[1])
+
+ ary.reject { |e| e =~ pattern }
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# reverse.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:reverse, :type => :rvalue, :doc => <<-EOS
+Reverses the order of a string or array.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "reverse(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'reverse(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ result = value.reverse
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# rstrip.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:rstrip, :type => :rvalue, :doc => <<-EOS
+Strips leading spaces to the right of the string.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "rstrip(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'rstrip(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ if value.is_a?(Array)
+ result = value.collect { |i| i.is_a?(String) ? i.rstrip : i }
+ else
+ result = value.rstrip
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# shuffle.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:shuffle, :type => :rvalue, :doc => <<-EOS
+Randomizes the order of a string or array elements.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "shuffle(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'shuffle(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ result = value.clone
+
+ string = value.is_a?(String) ? true : false
+
+ # Check whether it makes sense to shuffle ...
+ return result if result.size <= 1
+
+ # We turn any string value into an array to be able to shuffle ...
+ result = string ? result.split('') : result
+
+ elements = result.size
+
+ # Simple implementation of Fisher–Yates in-place shuffle ...
+ elements.times do |i|
+ j = rand(elements - i) + i
+ result[j], result[i] = result[i], result[j]
+ end
+
+ result = string ? result.join : result
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# size.rb
+#
+
+# TODO(Krzysztof Wilczynski): Support for hashes would be nice too ...
+
+module Puppet::Parser::Functions
+ newfunction(:size, :type => :rvalue, :doc => <<-EOS
+Returns the number of elements in a string or array.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "size(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ item = arguments[0]
+
+ if item.is_a?(String)
+
+ begin
+ #
+ # Check whether your item is a numeric value or not ...
+ # This will take care about positive and/or negative numbers
+ # for both integer and floating-point values ...
+ #
+ # Please note that Puppet has no notion of hexadecimal
+ # nor octal numbers for its DSL at this point in time ...
+ #
+ Float(item)
+
+ raise(Puppet::ParseError, 'size(): Requires either ' +
+ 'string or array to work with')
+
+ rescue ArgumentError
+ result = item.size
+ end
+
+ elsif item.is_a?(Array)
+ result = item.size
+ else
+ raise(Puppet::ParseError, 'size(): Unknown type given')
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# sort.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:sort, :type => :rvalue, :doc => <<-EOS
+Sorts strings and arrays lexically.
+ EOS
+ ) do |arguments|
+
+ if (arguments.size != 1) then
+ raise(Puppet::ParseError, "sort(): Wrong number of arguments "+
+ "given #{arguments.size} for 1")
+ end
+
+ value = arguments[0]
+
+ if value.is_a?(Array) then
+ value.sort
+ elsif value.is_a?(String) then
+ value.split("").sort.join("")
+ end
+
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# squeeze.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:squeeze, :type => :rvalue, :doc => <<-EOS
+Returns a new string where runs of the same character that occur in this set are replaced by a single character.
+ EOS
+ ) do |arguments|
+
+ if ((arguments.size != 2) and (arguments.size != 1)) then
+ raise(Puppet::ParseError, "squeeze(): Wrong number of arguments "+
+ "given #{arguments.size} for 2 or 1")
+ end
+
+ item = arguments[0]
+ squeezeval = arguments[1]
+
+ if item.is_a?(Array) then
+ if squeezeval then
+ item.collect { |i| i.squeeze(squeezeval) }
+ else
+ item.collect { |i| i.squeeze }
+ end
+ else
+ if squeezeval then
+ item.squeeze(squeezeval)
+ else
+ item.squeeze
+ end
+ end
+
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# str2bool.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:str2bool, :type => :rvalue, :doc => <<-EOS
+This converts a string to a boolean. This attempt to convert strings that
+contain things like: y, 1, t, true to 'true' and strings that contain things
+like: 0, f, n, false, no to 'false'.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "str2bool(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ string = arguments[0]
+
+ # If string is already Boolean, return it
+ if !!string == string
+ return string
+ end
+
+ unless string.is_a?(String)
+ raise(Puppet::ParseError, 'str2bool(): Requires either ' +
+ 'string to work with')
+ end
+
+ # We consider all the yes, no, y, n and so on too ...
+ result = case string
+ #
+ # This is how undef looks like in Puppet ...
+ # We yield false in this case.
+ #
+ when /^$/, '' then false # Empty string will be false ...
+ when /^(1|t|y|true|yes)$/ then true
+ when /^(0|f|n|false|no)$/ then false
+ when /^(undef|undefined)$/ then false # This is not likely to happen ...
+ else
+ raise(Puppet::ParseError, 'str2bool(): Unknown type of boolean given')
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# str2saltedsha512.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:str2saltedsha512, :type => :rvalue, :doc => <<-EOS
+This converts a string to a salted-SHA512 password hash (which is used for
+OS X versions >= 10.7). Given any simple string, you will get a hex version
+of a salted-SHA512 password hash that can be inserted into your Puppet
+manifests as a valid password attribute.
+ EOS
+ ) do |arguments|
+ require 'digest/sha2'
+
+ raise(Puppet::ParseError, "str2saltedsha512(): Wrong number of arguments " +
+ "passed (#{arguments.size} but we require 1)") if arguments.size != 1
+
+ password = arguments[0]
+
+ unless password.is_a?(String)
+ raise(Puppet::ParseError, 'str2saltedsha512(): Requires a ' +
+ "String argument, you passed: #{password.class}")
+ end
+
+ seedint = rand(2**31 - 1)
+ seedstring = Array(seedint).pack("L")
+ saltedpass = Digest::SHA512.digest(seedstring + password)
+ (seedstring + saltedpass).unpack('H*')[0]
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# strftime.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:strftime, :type => :rvalue, :doc => <<-EOS
+This function returns formatted time.
+
+*Examples:*
+
+To return the time since epoch:
+
+ strftime("%s")
+
+To return the date:
+
+ strftime("%Y-%m-%d")
+
+*Format meaning:*
+
+ %a - The abbreviated weekday name (``Sun'')
+ %A - The full weekday name (``Sunday'')
+ %b - The abbreviated month name (``Jan'')
+ %B - The full month name (``January'')
+ %c - The preferred local date and time representation
+ %C - Century (20 in 2009)
+ %d - Day of the month (01..31)
+ %D - Date (%m/%d/%y)
+ %e - Day of the month, blank-padded ( 1..31)
+ %F - Equivalent to %Y-%m-%d (the ISO 8601 date format)
+ %h - Equivalent to %b
+ %H - Hour of the day, 24-hour clock (00..23)
+ %I - Hour of the day, 12-hour clock (01..12)
+ %j - Day of the year (001..366)
+ %k - hour, 24-hour clock, blank-padded ( 0..23)
+ %l - hour, 12-hour clock, blank-padded ( 0..12)
+ %L - Millisecond of the second (000..999)
+ %m - Month of the year (01..12)
+ %M - Minute of the hour (00..59)
+ %n - Newline (\n)
+ %N - Fractional seconds digits, default is 9 digits (nanosecond)
+ %3N millisecond (3 digits)
+ %6N microsecond (6 digits)
+ %9N nanosecond (9 digits)
+ %p - Meridian indicator (``AM'' or ``PM'')
+ %P - Meridian indicator (``am'' or ``pm'')
+ %r - time, 12-hour (same as %I:%M:%S %p)
+ %R - time, 24-hour (%H:%M)
+ %s - Number of seconds since 1970-01-01 00:00:00 UTC.
+ %S - Second of the minute (00..60)
+ %t - Tab character (\t)
+ %T - time, 24-hour (%H:%M:%S)
+ %u - Day of the week as a decimal, Monday being 1. (1..7)
+ %U - Week number of the current year,
+ starting with the first Sunday as the first
+ day of the first week (00..53)
+ %v - VMS date (%e-%b-%Y)
+ %V - Week number of year according to ISO 8601 (01..53)
+ %W - Week number of the current year,
+ starting with the first Monday as the first
+ day of the first week (00..53)
+ %w - Day of the week (Sunday is 0, 0..6)
+ %x - Preferred representation for the date alone, no time
+ %X - Preferred representation for the time alone, no date
+ %y - Year without a century (00..99)
+ %Y - Year with century
+ %z - Time zone as hour offset from UTC (e.g. +0900)
+ %Z - Time zone name
+ %% - Literal ``%'' character
+ EOS
+ ) do |arguments|
+
+ # Technically we support two arguments but only first is mandatory ...
+ raise(Puppet::ParseError, "strftime(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ format = arguments[0]
+
+ raise(Puppet::ParseError, 'strftime(): You must provide ' +
+ 'format for evaluation') if format.empty?
+
+ # The Time Zone argument is optional ...
+ time_zone = arguments[1] if arguments[1]
+
+ time = Time.new
+
+ # There is probably a better way to handle Time Zone ...
+ if time_zone and not time_zone.empty?
+ original_zone = ENV['TZ']
+
+ local_time = time.clone
+ local_time = local_time.utc
+
+ ENV['TZ'] = time_zone
+
+ time = local_time.localtime
+
+ ENV['TZ'] = original_zone
+ end
+
+ result = time.strftime(format)
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# strip.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:strip, :type => :rvalue, :doc => <<-EOS
+This function removes leading and trailing whitespace from a string or from
+every string inside an array.
+
+*Examples:*
+
+ strip(" aaa ")
+
+Would result in: "aaa"
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "strip(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'strip(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ if value.is_a?(Array)
+ result = value.collect { |i| i.is_a?(String) ? i.strip : i }
+ else
+ result = value.strip
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# suffix.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:suffix, :type => :rvalue, :doc => <<-EOS
+This function applies a suffix to all elements in an array.
+
+*Examples:*
+
+ suffix(['a','b','c'], 'p')
+
+Will return: ['ap','bp','cp']
+ EOS
+ ) do |arguments|
+
+ # Technically we support two arguments but only first is mandatory ...
+ raise(Puppet::ParseError, "suffix(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ array = arguments[0]
+
+ unless array.is_a?(Array)
+ raise Puppet::ParseError, "suffix(): expected first argument to be an Array, got #{array.inspect}"
+ end
+
+ suffix = arguments[1] if arguments[1]
+
+ if suffix
+ unless suffix.is_a? String
+ raise Puppet::ParseError, "suffix(): expected second argument to be a String, got #{suffix.inspect}"
+ end
+ end
+
+ # Turn everything into string same as join would do ...
+ result = array.collect do |i|
+ i = i.to_s
+ suffix ? i + suffix : i
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# swapcase.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:swapcase, :type => :rvalue, :doc => <<-EOS
+This function will swap the existing case of a string.
+
+*Examples:*
+
+ swapcase("aBcD")
+
+Would result in: "AbCd"
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "swapcase(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'swapcase(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ if value.is_a?(Array)
+ # Numbers in Puppet are often string-encoded which is troublesome ...
+ result = value.collect { |i| i.is_a?(String) ? i.swapcase : i }
+ else
+ result = value.swapcase
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# time.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:time, :type => :rvalue, :doc => <<-EOS
+This function will return the current time since epoch as an integer.
+
+*Examples:*
+
+ time()
+
+Will return something like: 1311972653
+ EOS
+ ) do |arguments|
+
+ # The Time Zone argument is optional ...
+ time_zone = arguments[0] if arguments[0]
+
+ if (arguments.size != 0) and (arguments.size != 1) then
+ raise(Puppet::ParseError, "time(): Wrong number of arguments "+
+ "given #{arguments.size} for 0 or 1")
+ end
+
+ time = Time.new
+
+ # There is probably a better way to handle Time Zone ...
+ if time_zone and not time_zone.empty?
+ original_zone = ENV['TZ']
+
+ local_time = time.clone
+ local_time = local_time.utc
+
+ ENV['TZ'] = time_zone
+
+ time = local_time.localtime
+
+ ENV['TZ'] = original_zone
+ end
+
+ # Calling Time#to_i on a receiver changes it. Trust me I am the Doctor.
+ result = time.strftime('%s')
+ result = result.to_i
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:to_bytes, :type => :rvalue, :doc => <<-EOS
+ Converts the argument into bytes, for example 4 kB becomes 4096.
+ Takes a single string value as an argument.
+ These conversions reflect a layperson's understanding of
+ 1 MB = 1024 KB, when in fact 1 MB = 1000 KB, and 1 MiB = 1024 KiB.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "to_bytes(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size != 1
+
+ arg = arguments[0]
+
+ return arg if arg.is_a? Numeric
+
+ value,prefix = */([0-9.e+-]*)\s*([^bB]?)/.match(arg)[1,2]
+
+ value = value.to_f
+ case prefix
+ when '' then return value.to_i
+ when 'k' then return (value*(1<<10)).to_i
+ when 'M' then return (value*(1<<20)).to_i
+ when 'G' then return (value*(1<<30)).to_i
+ when 'T' then return (value*(1<<40)).to_i
+ when 'P' then return (value*(1<<50)).to_i
+ when 'E' then return (value*(1<<60)).to_i
+ else raise Puppet::ParseError, "to_bytes(): Unknown prefix #{prefix}"
+ end
+ end
+end
--- /dev/null
+#
+# type.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:type, :type => :rvalue, :doc => <<-EOS
+ DEPRECATED: This function will cease to function on Puppet 4; please use type3x() before upgrading to puppet 4 for backwards-compatibility, or migrate to the new parser's typing system.
+ EOS
+ ) do |args|
+
+ warning("type() DEPRECATED: This function will cease to function on Puppet 4; please use type3x() before upgrading to puppet 4 for backwards-compatibility, or migrate to the new parser's typing system.")
+ if ! Puppet::Parser::Functions.autoloader.loaded?(:type3x)
+ Puppet::Parser::Functions.autoloader.load(:type3x)
+ end
+ function_type3x(args + [false])
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# type3x.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:type3x, :type => :rvalue, :doc => <<-EOS
+DEPRECATED: This function will be removed when puppet 3 support is dropped; please migrate to the new parser's typing system.
+
+Returns the type when passed a value. Type can be one of:
+
+* string
+* array
+* hash
+* float
+* integer
+* boolean
+ EOS
+ ) do |args|
+ raise(Puppet::ParseError, "type3x(): Wrong number of arguments " +
+ "given (#{args.size} for 1)") if args.size < 1
+
+ value = args[0]
+
+ klass = value.class
+
+ if not [TrueClass, FalseClass, Array, Bignum, Fixnum, Float, Hash, String].include?(klass)
+ raise(Puppet::ParseError, 'type3x(): Unknown type')
+ end
+
+ klass = klass.to_s # Ugly ...
+
+ # We note that Integer is the parent to Bignum and Fixnum ...
+ result = case klass
+ when /^(?:Big|Fix)num$/ then 'integer'
+ when /^(?:True|False)Class$/ then 'boolean'
+ else klass
+ end
+
+ if result == "String" then
+ if value == value.to_i.to_s then
+ result = "Integer"
+ elsif value == value.to_f.to_s then
+ result = "Float"
+ end
+ end
+
+ return result.downcase
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# union.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:union, :type => :rvalue, :doc => <<-EOS
+This function returns a union of two arrays.
+
+*Examples:*
+
+ union(["a","b","c"],["b","c","d"])
+
+Would return: ["a","b","c","d"]
+ EOS
+ ) do |arguments|
+
+ # Two arguments are required
+ raise(Puppet::ParseError, "union(): Wrong number of arguments " +
+ "given (#{arguments.size} for 2)") if arguments.size != 2
+
+ first = arguments[0]
+ second = arguments[1]
+
+ unless first.is_a?(Array) && second.is_a?(Array)
+ raise(Puppet::ParseError, 'union(): Requires 2 arrays')
+ end
+
+ result = first | second
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# unique.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:unique, :type => :rvalue, :doc => <<-EOS
+This function will remove duplicates from strings and arrays.
+
+*Examples:*
+
+ unique("aabbcc")
+
+Will return:
+
+ abc
+
+You can also use this with arrays:
+
+ unique(["a","a","b","b","c","c"])
+
+This returns:
+
+ ["a","b","c"]
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "unique(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'unique(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ result = value.clone
+
+ string = value.is_a?(String) ? true : false
+
+ # We turn any string value into an array to be able to shuffle ...
+ result = string ? result.split('') : result
+ result = result.uniq # Remove duplicates ...
+ result = string ? result.join : result
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# upcase.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:upcase, :type => :rvalue, :doc => <<-EOS
+Converts a string or an array of strings to uppercase.
+
+*Examples:*
+
+ upcase("abcd")
+
+Will return:
+
+ ASDF
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "upcase(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size != 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(Hash) || value.respond_to?(:upcase)
+ raise(Puppet::ParseError, 'upcase(): Requires an ' +
+ 'array, hash or object that responds to upcase in order to work')
+ end
+
+ if value.is_a?(Array)
+ # Numbers in Puppet are often string-encoded which is troublesome ...
+ result = value.collect { |i| function_upcase([i]) }
+ elsif value.is_a?(Hash)
+ result = {}
+ value.each_pair do |k, v|
+ result[function_upcase([k])] = function_upcase([v])
+ end
+ else
+ result = value.upcase
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# uriescape.rb
+#
+require 'uri'
+
+module Puppet::Parser::Functions
+ newfunction(:uriescape, :type => :rvalue, :doc => <<-EOS
+ Urlencodes a string or array of strings.
+ Requires either a single string or an array as an input.
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "uriescape(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ value = arguments[0]
+
+ unless value.is_a?(Array) || value.is_a?(String)
+ raise(Puppet::ParseError, 'uriescape(): Requires either ' +
+ 'array or string to work with')
+ end
+
+ if value.is_a?(Array)
+ # Numbers in Puppet are often string-encoded which is troublesome ...
+ result = value.collect { |i| i.is_a?(String) ? URI.escape(i) : i }
+ else
+ result = URI.escape(value)
+ end
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:validate_absolute_path, :doc => <<-'ENDHEREDOC') do |args|
+ Validate the string represents an absolute path in the filesystem. This function works
+ for windows and unix style paths.
+
+ The following values will pass:
+
+ $my_path = 'C:/Program Files (x86)/Puppet Labs/Puppet'
+ validate_absolute_path($my_path)
+ $my_path2 = '/var/lib/puppet'
+ validate_absolute_path($my_path2)
+ $my_path3 = ['C:/Program Files (x86)/Puppet Labs/Puppet','C:/Program Files/Puppet Labs/Puppet']
+ validate_absolute_path($my_path3)
+ $my_path4 = ['/var/lib/puppet','/usr/share/puppet']
+ validate_absolute_path($my_path4)
+
+ The following values will fail, causing compilation to abort:
+
+ validate_absolute_path(true)
+ validate_absolute_path('../var/lib/puppet')
+ validate_absolute_path('var/lib/puppet')
+ validate_absolute_path([ 'var/lib/puppet', '/var/foo' ])
+ validate_absolute_path([ '/var/lib/puppet', 'var/foo' ])
+ $undefined = undef
+ validate_absolute_path($undefined)
+
+ ENDHEREDOC
+
+ require 'puppet/util'
+
+ unless args.length > 0 then
+ raise Puppet::ParseError, ("validate_absolute_path(): wrong number of arguments (#{args.length}; must be > 0)")
+ end
+
+ args.each do |arg|
+ # put arg to candidate var to be able to replace it
+ candidates = arg
+ # if arg is just a string with a path to test, convert it to an array
+ # to avoid test code duplication
+ unless arg.is_a?(Array) then
+ candidates = Array.new(1,arg)
+ end
+ # iterate over all pathes within the candidates array
+ candidates.each do |path|
+ # This logic was borrowed from
+ # [lib/puppet/file_serving/base.rb](https://github.com/puppetlabs/puppet/blob/master/lib/puppet/file_serving/base.rb)
+ # Puppet 2.7 and beyond will have Puppet::Util.absolute_path? Fall back to a back-ported implementation otherwise.
+ if Puppet::Util.respond_to?(:absolute_path?) then
+ unless Puppet::Util.absolute_path?(path, :posix) or Puppet::Util.absolute_path?(path, :windows)
+ raise Puppet::ParseError, ("#{path.inspect} is not an absolute path.")
+ end
+ else
+ # This code back-ported from 2.7.x's lib/puppet/util.rb Puppet::Util.absolute_path?
+ # Determine in a platform-specific way whether a path is absolute. This
+ # defaults to the local platform if none is specified.
+ # Escape once for the string literal, and once for the regex.
+ slash = '[\\\\/]'
+ name = '[^\\\\/]+'
+ regexes = {
+ :windows => %r!^(([A-Z]:#{slash})|(#{slash}#{slash}#{name}#{slash}#{name})|(#{slash}#{slash}\?#{slash}#{name}))!i,
+ :posix => %r!^/!,
+ }
+ rval = (!!(path =~ regexes[:posix])) || (!!(path =~ regexes[:windows]))
+ rval or raise Puppet::ParseError, ("#{path.inspect} is not an absolute path.")
+ end
+ end
+ end
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:validate_array, :doc => <<-'ENDHEREDOC') do |args|
+ Validate that all passed values are array data structures. Abort catalog
+ compilation if any value fails this check.
+
+ The following values will pass:
+
+ $my_array = [ 'one', 'two' ]
+ validate_array($my_array)
+
+ The following values will fail, causing compilation to abort:
+
+ validate_array(true)
+ validate_array('some_string')
+ $undefined = undef
+ validate_array($undefined)
+
+ ENDHEREDOC
+
+ unless args.length > 0 then
+ raise Puppet::ParseError, ("validate_array(): wrong number of arguments (#{args.length}; must be > 0)")
+ end
+
+ args.each do |arg|
+ unless arg.is_a?(Array)
+ raise Puppet::ParseError, ("#{arg.inspect} is not an Array. It looks to be a #{arg.class}")
+ end
+ end
+
+ end
+
+end
--- /dev/null
+require 'tempfile'
+
+module Puppet::Parser::Functions
+ newfunction(:validate_augeas, :doc => <<-'ENDHEREDOC') do |args|
+ Perform validation of a string using an Augeas lens
+ The first argument of this function should be a string to
+ test, and the second argument should be the name of the Augeas lens to use.
+ If Augeas fails to parse the string with the lens, the compilation will
+ abort with a parse error.
+
+ A third argument can be specified, listing paths which should
+ not be found in the file. The `$file` variable points to the location
+ of the temporary file being tested in the Augeas tree.
+
+ For example, if you want to make sure your passwd content never contains
+ a user `foo`, you could write:
+
+ validate_augeas($passwdcontent, 'Passwd.lns', ['$file/foo'])
+
+ Or if you wanted to ensure that no users used the '/bin/barsh' shell,
+ you could use:
+
+ validate_augeas($passwdcontent, 'Passwd.lns', ['$file/*[shell="/bin/barsh"]']
+
+ If a fourth argument is specified, this will be the error message raised and
+ seen by the user.
+
+ A helpful error message can be returned like this:
+
+ validate_augeas($sudoerscontent, 'Sudoers.lns', [], 'Failed to validate sudoers content with Augeas')
+
+ ENDHEREDOC
+ unless Puppet.features.augeas?
+ raise Puppet::ParseError, ("validate_augeas(): this function requires the augeas feature. See http://projects.puppetlabs.com/projects/puppet/wiki/Puppet_Augeas#Pre-requisites for how to activate it.")
+ end
+
+ if (args.length < 2) or (args.length > 4) then
+ raise Puppet::ParseError, ("validate_augeas(): wrong number of arguments (#{args.length}; must be 2, 3, or 4)")
+ end
+
+ msg = args[3] || "validate_augeas(): Failed to validate content against #{args[1].inspect}"
+
+ require 'augeas'
+ aug = Augeas::open(nil, nil, Augeas::NO_MODL_AUTOLOAD)
+ begin
+ content = args[0]
+
+ # Test content in a temporary file
+ tmpfile = Tempfile.new("validate_augeas")
+ begin
+ tmpfile.write(content)
+ ensure
+ tmpfile.close
+ end
+
+ # Check for syntax
+ lens = args[1]
+ aug.transform(
+ :lens => lens,
+ :name => 'Validate_augeas',
+ :incl => tmpfile.path
+ )
+ aug.load!
+
+ unless aug.match("/augeas/files#{tmpfile.path}//error").empty?
+ error = aug.get("/augeas/files#{tmpfile.path}//error/message")
+ msg += " with error: #{error}"
+ raise Puppet::ParseError, (msg)
+ end
+
+ # Launch unit tests
+ tests = args[2] || []
+ aug.defvar('file', "/files#{tmpfile.path}")
+ tests.each do |t|
+ msg += " testing path #{t}"
+ raise Puppet::ParseError, (msg) unless aug.match(t).empty?
+ end
+ ensure
+ aug.close
+ tmpfile.unlink
+ end
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:validate_bool, :doc => <<-'ENDHEREDOC') do |args|
+ Validate that all passed values are either true or false. Abort catalog
+ compilation if any value fails this check.
+
+ The following values will pass:
+
+ $iamtrue = true
+ validate_bool(true)
+ validate_bool(true, true, false, $iamtrue)
+
+ The following values will fail, causing compilation to abort:
+
+ $some_array = [ true ]
+ validate_bool("false")
+ validate_bool("true")
+ validate_bool($some_array)
+
+ ENDHEREDOC
+
+ unless args.length > 0 then
+ raise Puppet::ParseError, ("validate_bool(): wrong number of arguments (#{args.length}; must be > 0)")
+ end
+
+ args.each do |arg|
+ unless function_is_bool([arg])
+ raise Puppet::ParseError, ("#{arg.inspect} is not a boolean. It looks to be a #{arg.class}")
+ end
+ end
+
+ end
+
+end
--- /dev/null
+require 'puppet/util/execution'
+require 'tempfile'
+
+module Puppet::Parser::Functions
+ newfunction(:validate_cmd, :doc => <<-'ENDHEREDOC') do |args|
+ Perform validation of a string with an external command.
+ The first argument of this function should be a string to
+ test, and the second argument should be a path to a test command
+ taking a % as a placeholder for the file path (will default to the end).
+ If the command, launched against a tempfile containing the passed string,
+ returns a non-null value, compilation will abort with a parse error.
+
+ If a third argument is specified, this will be the error message raised and
+ seen by the user.
+
+ A helpful error message can be returned like this:
+
+ Example:
+
+ # Defaults to end of path
+ validate_cmd($sudoerscontent, '/usr/sbin/visudo -c -f', 'Visudo failed to validate sudoers content')
+
+ # % as file location
+ validate_cmd($haproxycontent, '/usr/sbin/haproxy -f % -c', 'Haproxy failed to validate config content')
+
+ ENDHEREDOC
+ if (args.length < 2) or (args.length > 3) then
+ raise Puppet::ParseError, ("validate_cmd(): wrong number of arguments (#{args.length}; must be 2 or 3)")
+ end
+
+ msg = args[2] || "validate_cmd(): failed to validate content with command #{args[1].inspect}"
+
+ content = args[0]
+ checkscript = args[1]
+
+ # Test content in a temporary file
+ tmpfile = Tempfile.new("validate_cmd")
+ begin
+ tmpfile.write(content)
+ tmpfile.close
+
+ if checkscript =~ /\s%(\s|$)/
+ check_with_correct_location = checkscript.gsub(/%/,tmpfile.path)
+ else
+ check_with_correct_location = "#{checkscript} #{tmpfile.path}"
+ end
+
+ if Puppet::Util::Execution.respond_to?('execute')
+ Puppet::Util::Execution.execute(check_with_correct_location)
+ else
+ Puppet::Util.execute(check_with_correct_location)
+ end
+ rescue Puppet::ExecutionFailure => detail
+ msg += "\n#{detail}"
+ raise Puppet::ParseError, msg
+ rescue Exception => detail
+ msg += "\n#{detail.class.name} #{detail}"
+ raise Puppet::ParseError, msg
+ ensure
+ tmpfile.unlink
+ end
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:validate_hash, :doc => <<-'ENDHEREDOC') do |args|
+ Validate that all passed values are hash data structures. Abort catalog
+ compilation if any value fails this check.
+
+ The following values will pass:
+
+ $my_hash = { 'one' => 'two' }
+ validate_hash($my_hash)
+
+ The following values will fail, causing compilation to abort:
+
+ validate_hash(true)
+ validate_hash('some_string')
+ $undefined = undef
+ validate_hash($undefined)
+
+ ENDHEREDOC
+
+ unless args.length > 0 then
+ raise Puppet::ParseError, ("validate_hash(): wrong number of arguments (#{args.length}; must be > 0)")
+ end
+
+ args.each do |arg|
+ unless arg.is_a?(Hash)
+ raise Puppet::ParseError, ("#{arg.inspect} is not a Hash. It looks to be a #{arg.class}")
+ end
+ end
+
+ end
+
+end
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:validate_integer, :doc => <<-'ENDHEREDOC') do |args|
+ Validate that the first argument is an integer (or an array of integers). Abort catalog compilation if any of the checks fail.
+
+ The second argument is optional and passes a maximum. (All elements of) the first argument has to be less or equal to this max.
+
+ The third argument is optional and passes a minimum. (All elements of) the first argument has to be greater or equal to this min.
+ If, and only if, a minimum is given, the second argument may be an empty string or undef, which will be handled to just check
+ if (all elements of) the first argument are greater or equal to the given minimum.
+
+ It will fail if the first argument is not an integer or array of integers, and if arg 2 and arg 3 are not convertable to an integer.
+
+ The following values will pass:
+
+ validate_integer(1)
+ validate_integer(1, 2)
+ validate_integer(1, 1)
+ validate_integer(1, 2, 0)
+ validate_integer(2, 2, 2)
+ validate_integer(2, '', 0)
+ validate_integer(2, undef, 0)
+ $foo = undef
+ validate_integer(2, $foo, 0)
+ validate_integer([1,2,3,4,5], 6)
+ validate_integer([1,2,3,4,5], 6, 0)
+
+ Plus all of the above, but any combination of values passed as strings ('1' or "1").
+ Plus all of the above, but with (correct) combinations of negative integer values.
+
+ The following values will not:
+
+ validate_integer(true)
+ validate_integer(false)
+ validate_integer(7.0)
+ validate_integer({ 1 => 2 })
+ $foo = undef
+ validate_integer($foo)
+ validate_integer($foobaridontexist)
+
+ validate_integer(1, 0)
+ validate_integer(1, true)
+ validate_integer(1, '')
+ validate_integer(1, undef)
+ validate_integer(1, , 0)
+ validate_integer(1, 2, 3)
+ validate_integer(1, 3, 2)
+ validate_integer(1, 3, true)
+
+ Plus all of the above, but any combination of values passed as strings ('false' or "false").
+ Plus all of the above, but with incorrect combinations of negative integer values.
+ Plus all of the above, but with non-integer crap in arrays or maximum / minimum argument.
+
+ ENDHEREDOC
+
+ # tell the user we need at least one, and optionally up to two other parameters
+ raise Puppet::ParseError, "validate_integer(): Wrong number of arguments; must be 1, 2 or 3, got #{args.length}" unless args.length > 0 and args.length < 4
+
+ input, max, min = *args
+
+ # check maximum parameter
+ if args.length > 1
+ max = max.to_s
+ # allow max to be empty (or undefined) if we have a minimum set
+ if args.length > 2 and max == ''
+ max = nil
+ else
+ begin
+ max = Integer(max)
+ rescue TypeError, ArgumentError
+ raise Puppet::ParseError, "validate_integer(): Expected second argument to be unset or an Integer, got #{max}:#{max.class}"
+ end
+ end
+ else
+ max = nil
+ end
+
+ # check minimum parameter
+ if args.length > 2
+ begin
+ min = Integer(min.to_s)
+ rescue TypeError, ArgumentError
+ raise Puppet::ParseError, "validate_integer(): Expected third argument to be unset or an Integer, got #{min}:#{min.class}"
+ end
+ else
+ min = nil
+ end
+
+ # ensure that min < max
+ if min and max and min > max
+ raise Puppet::ParseError, "validate_integer(): Expected second argument to be larger than third argument, got #{max} < #{min}"
+ end
+
+ # create lamba validator function
+ validator = lambda do |num|
+ # check input < max
+ if max and num > max
+ raise Puppet::ParseError, "validate_integer(): Expected #{input.inspect} to be smaller or equal to #{max}, got #{input.inspect}."
+ end
+ # check input > min (this will only be checked if no exception has been raised before)
+ if min and num < min
+ raise Puppet::ParseError, "validate_integer(): Expected #{input.inspect} to be greater or equal to #{min}, got #{input.inspect}."
+ end
+ end
+
+ # if this is an array, handle it.
+ case input
+ when Array
+ # check every element of the array
+ input.each_with_index do |arg, pos|
+ begin
+ arg = Integer(arg.to_s)
+ validator.call(arg)
+ rescue TypeError, ArgumentError
+ raise Puppet::ParseError, "validate_integer(): Expected element at array position #{pos} to be an Integer, got #{arg.class}"
+ end
+ end
+ # for the sake of compatibility with ruby 1.8, we need extra handling of hashes
+ when Hash
+ raise Puppet::ParseError, "validate_integer(): Expected first argument to be an Integer or Array, got #{input.class}"
+ # check the input. this will also fail any stuff other than pure, shiny integers
+ else
+ begin
+ input = Integer(input.to_s)
+ validator.call(input)
+ rescue TypeError, ArgumentError
+ raise Puppet::ParseError, "validate_integer(): Expected first argument to be an Integer or Array, got #{input.class}"
+ end
+ end
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:validate_ipv4_address, :doc => <<-ENDHEREDOC
+ Validate that all values passed are valid IPv4 addresses.
+ Fail compilation if any value fails this check.
+
+ The following values will pass:
+
+ $my_ip = "1.2.3.4"
+ validate_ipv4_address($my_ip)
+ validate_bool("8.8.8.8", "172.16.0.1", $my_ip)
+
+ The following values will fail, causing compilation to abort:
+
+ $some_array = [ 1, true, false, "garbage string", "3ffe:505:2" ]
+ validate_ipv4_address($some_array)
+
+ ENDHEREDOC
+ ) do |args|
+
+ require "ipaddr"
+ rescuable_exceptions = [ ArgumentError ]
+
+ if defined?(IPAddr::InvalidAddressError)
+ rescuable_exceptions << IPAddr::InvalidAddressError
+ end
+
+ unless args.length > 0 then
+ raise Puppet::ParseError, ("validate_ipv4_address(): wrong number of arguments (#{args.length}; must be > 0)")
+ end
+
+ args.each do |arg|
+ unless arg.is_a?(String)
+ raise Puppet::ParseError, "#{arg.inspect} is not a string."
+ end
+
+ begin
+ unless IPAddr.new(arg).ipv4?
+ raise Puppet::ParseError, "#{arg.inspect} is not a valid IPv4 address."
+ end
+ rescue *rescuable_exceptions
+ raise Puppet::ParseError, "#{arg.inspect} is not a valid IPv4 address."
+ end
+ end
+
+ end
+
+end
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:validate_ipv6_address, :doc => <<-ENDHEREDOC
+ Validate that all values passed are valid IPv6 addresses.
+ Fail compilation if any value fails this check.
+
+ The following values will pass:
+
+ $my_ip = "3ffe:505:2"
+ validate_ipv6_address(1)
+ validate_ipv6_address($my_ip)
+ validate_bool("fe80::baf6:b1ff:fe19:7507", $my_ip)
+
+ The following values will fail, causing compilation to abort:
+
+ $some_array = [ true, false, "garbage string", "1.2.3.4" ]
+ validate_ipv6_address($some_array)
+
+ ENDHEREDOC
+ ) do |args|
+
+ require "ipaddr"
+ rescuable_exceptions = [ ArgumentError ]
+
+ if defined?(IPAddr::InvalidAddressError)
+ rescuable_exceptions << IPAddr::InvalidAddressError
+ end
+
+ unless args.length > 0 then
+ raise Puppet::ParseError, ("validate_ipv6_address(): wrong number of arguments (#{args.length}; must be > 0)")
+ end
+
+ args.each do |arg|
+ unless arg.is_a?(String)
+ raise Puppet::ParseError, "#{arg.inspect} is not a string."
+ end
+
+ begin
+ unless IPAddr.new(arg).ipv6?
+ raise Puppet::ParseError, "#{arg.inspect} is not a valid IPv6 address."
+ end
+ rescue *rescuable_exceptions
+ raise Puppet::ParseError, "#{arg.inspect} is not a valid IPv6 address."
+ end
+ end
+
+ end
+
+end
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:validate_numeric, :doc => <<-'ENDHEREDOC') do |args|
+ Validate that the first argument is a numeric value (or an array of numeric values). Abort catalog compilation if any of the checks fail.
+
+ The second argument is optional and passes a maximum. (All elements of) the first argument has to be less or equal to this max.
+
+ The third argument is optional and passes a minimum. (All elements of) the first argument has to be greater or equal to this min.
+ If, and only if, a minimum is given, the second argument may be an empty string or undef, which will be handled to just check
+ if (all elements of) the first argument are greater or equal to the given minimum.
+
+ It will fail if the first argument is not a numeric (Integer or Float) or array of numerics, and if arg 2 and arg 3 are not convertable to a numeric.
+
+ For passing and failing usage, see `validate_integer()`. It is all the same for validate_numeric, yet now floating point values are allowed, too.
+
+ ENDHEREDOC
+
+ # tell the user we need at least one, and optionally up to two other parameters
+ raise Puppet::ParseError, "validate_numeric(): Wrong number of arguments; must be 1, 2 or 3, got #{args.length}" unless args.length > 0 and args.length < 4
+
+ input, max, min = *args
+
+ # check maximum parameter
+ if args.length > 1
+ max = max.to_s
+ # allow max to be empty (or undefined) if we have a minimum set
+ if args.length > 2 and max == ''
+ max = nil
+ else
+ begin
+ max = Float(max)
+ rescue TypeError, ArgumentError
+ raise Puppet::ParseError, "validate_numeric(): Expected second argument to be unset or a Numeric, got #{max}:#{max.class}"
+ end
+ end
+ else
+ max = nil
+ end
+
+ # check minimum parameter
+ if args.length > 2
+ begin
+ min = Float(min.to_s)
+ rescue TypeError, ArgumentError
+ raise Puppet::ParseError, "validate_numeric(): Expected third argument to be unset or a Numeric, got #{min}:#{min.class}"
+ end
+ else
+ min = nil
+ end
+
+ # ensure that min < max
+ if min and max and min > max
+ raise Puppet::ParseError, "validate_numeric(): Expected second argument to be larger than third argument, got #{max} < #{min}"
+ end
+
+ # create lamba validator function
+ validator = lambda do |num|
+ # check input < max
+ if max and num > max
+ raise Puppet::ParseError, "validate_numeric(): Expected #{input.inspect} to be smaller or equal to #{max}, got #{input.inspect}."
+ end
+ # check input > min (this will only be checked if no exception has been raised before)
+ if min and num < min
+ raise Puppet::ParseError, "validate_numeric(): Expected #{input.inspect} to be greater or equal to #{min}, got #{input.inspect}."
+ end
+ end
+
+ # if this is an array, handle it.
+ case input
+ when Array
+ # check every element of the array
+ input.each_with_index do |arg, pos|
+ begin
+ arg = Float(arg.to_s)
+ validator.call(arg)
+ rescue TypeError, ArgumentError
+ raise Puppet::ParseError, "validate_numeric(): Expected element at array position #{pos} to be a Numeric, got #{arg.class}"
+ end
+ end
+ # for the sake of compatibility with ruby 1.8, we need extra handling of hashes
+ when Hash
+ raise Puppet::ParseError, "validate_integer(): Expected first argument to be a Numeric or Array, got #{input.class}"
+ # check the input. this will also fail any stuff other than pure, shiny integers
+ else
+ begin
+ input = Float(input.to_s)
+ validator.call(input)
+ rescue TypeError, ArgumentError
+ raise Puppet::ParseError, "validate_numeric(): Expected first argument to be a Numeric or Array, got #{input.class}"
+ end
+ end
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+ newfunction(:validate_re, :doc => <<-'ENDHEREDOC') do |args|
+ Perform simple validation of a string against one or more regular
+ expressions. The first argument of this function should be a string to
+ test, and the second argument should be a stringified regular expression
+ (without the // delimiters) or an array of regular expressions. If none
+ of the regular expressions match the string passed in, compilation will
+ abort with a parse error.
+
+ If a third argument is specified, this will be the error message raised and
+ seen by the user.
+
+ The following strings will validate against the regular expressions:
+
+ validate_re('one', '^one$')
+ validate_re('one', [ '^one', '^two' ])
+
+ The following strings will fail to validate, causing compilation to abort:
+
+ validate_re('one', [ '^two', '^three' ])
+
+ A helpful error message can be returned like this:
+
+ validate_re($::puppetversion, '^2.7', 'The $puppetversion fact value does not match 2.7')
+
+ ENDHEREDOC
+ if (args.length < 2) or (args.length > 3) then
+ raise Puppet::ParseError, ("validate_re(): wrong number of arguments (#{args.length}; must be 2 or 3)")
+ end
+
+ msg = args[2] || "validate_re(): #{args[0].inspect} does not match #{args[1].inspect}"
+
+ # We're using a flattened array here because we can't call String#any? in
+ # Ruby 1.9 like we can in Ruby 1.8
+ raise Puppet::ParseError, (msg) unless [args[1]].flatten.any? do |re_str|
+ args[0] =~ Regexp.compile(re_str)
+ end
+
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:validate_slength, :doc => <<-'ENDHEREDOC') do |args|
+ Validate that the first argument is a string (or an array of strings), and
+ less/equal to than the length of the second argument. An optional third
+ parameter can be given a the minimum length. It fails if the first
+ argument is not a string or array of strings, and if arg 2 and arg 3 are
+ not convertable to a number.
+
+ The following values will pass:
+
+ validate_slength("discombobulate",17)
+ validate_slength(["discombobulate","moo"],17)
+ validate_slength(["discombobulate","moo"],17,3)
+
+ The following valueis will not:
+
+ validate_slength("discombobulate",1)
+ validate_slength(["discombobulate","thermometer"],5)
+ validate_slength(["discombobulate","moo"],17,10)
+
+ ENDHEREDOC
+
+ raise Puppet::ParseError, "validate_slength(): Wrong number of arguments (#{args.length}; must be 2 or 3)" unless args.length == 2 or args.length == 3
+
+ input, max_length, min_length = *args
+
+ begin
+ max_length = Integer(max_length)
+ raise ArgumentError if max_length <= 0
+ rescue ArgumentError, TypeError
+ raise Puppet::ParseError, "validate_slength(): Expected second argument to be a positive Numeric, got #{max_length}:#{max_length.class}"
+ end
+
+ if min_length
+ begin
+ min_length = Integer(min_length)
+ raise ArgumentError if min_length < 0
+ rescue ArgumentError, TypeError
+ raise Puppet::ParseError, "validate_slength(): Expected third argument to be unset or a positive Numeric, got #{min_length}:#{min_length.class}"
+ end
+ else
+ min_length = 0
+ end
+
+ if min_length > max_length
+ raise Puppet::ParseError, "validate_slength(): Expected second argument to be larger than third argument"
+ end
+
+ validator = lambda do |str|
+ unless str.length <= max_length and str.length >= min_length
+ raise Puppet::ParseError, "validate_slength(): Expected length of #{input.inspect} to be between #{min_length} and #{max_length}, was #{input.length}"
+ end
+ end
+
+ case input
+ when String
+ validator.call(input)
+ when Array
+ input.each_with_index do |arg, pos|
+ if arg.is_a? String
+ validator.call(arg)
+ else
+ raise Puppet::ParseError, "validate_slength(): Expected element at array position #{pos} to be a String, got #{arg.class}"
+ end
+ end
+ else
+ raise Puppet::ParseError, "validate_slength(): Expected first argument to be a String or Array, got #{input.class}"
+ end
+ end
+end
--- /dev/null
+module Puppet::Parser::Functions
+
+ newfunction(:validate_string, :doc => <<-'ENDHEREDOC') do |args|
+ Validate that all passed values are string data structures. Abort catalog
+ compilation if any value fails this check.
+
+ The following values will pass:
+
+ $my_string = "one two"
+ validate_string($my_string, 'three')
+
+ The following values will fail, causing compilation to abort:
+
+ validate_string(true)
+ validate_string([ 'some', 'array' ])
+
+ Note: validate_string(undef) will not fail in this version of the
+ functions API (incl. current and future parser). Instead, use:
+
+ if $var == undef {
+ fail('...')
+ }
+
+ ENDHEREDOC
+
+ unless args.length > 0 then
+ raise Puppet::ParseError, ("validate_string(): wrong number of arguments (#{args.length}; must be > 0)")
+ end
+
+ args.each do |arg|
+ unless arg.is_a?(String)
+ raise Puppet::ParseError, ("#{arg.inspect} is not a string. It looks to be a #{arg.class}")
+ end
+ end
+
+ end
+
+end
--- /dev/null
+#
+# values.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:values, :type => :rvalue, :doc => <<-EOS
+When given a hash this function will return the values of that hash.
+
+*Examples:*
+
+ $hash = {
+ 'a' => 1,
+ 'b' => 2,
+ 'c' => 3,
+ }
+ values($hash)
+
+This example would return:
+
+ [1,2,3]
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "values(): Wrong number of arguments " +
+ "given (#{arguments.size} for 1)") if arguments.size < 1
+
+ hash = arguments[0]
+
+ unless hash.is_a?(Hash)
+ raise(Puppet::ParseError, 'values(): Requires hash to work with')
+ end
+
+ result = hash.values
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# values_at.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:values_at, :type => :rvalue, :doc => <<-EOS
+Finds value inside an array based on location.
+
+The first argument is the array you want to analyze, and the second element can
+be a combination of:
+
+* A single numeric index
+* A range in the form of 'start-stop' (eg. 4-9)
+* An array combining the above
+
+*Examples*:
+
+ values_at(['a','b','c'], 2)
+
+Would return ['c'].
+
+ values_at(['a','b','c'], ["0-1"])
+
+Would return ['a','b'].
+
+ values_at(['a','b','c','d','e'], [0, "2-3"])
+
+Would return ['a','c','d'].
+ EOS
+ ) do |arguments|
+
+ raise(Puppet::ParseError, "values_at(): Wrong number of " +
+ "arguments given (#{arguments.size} for 2)") if arguments.size < 2
+
+ array = arguments.shift
+
+ unless array.is_a?(Array)
+ raise(Puppet::ParseError, 'values_at(): Requires array to work with')
+ end
+
+ indices = [arguments.shift].flatten() # Get them all ... Pokemon ...
+
+ if not indices or indices.empty?
+ raise(Puppet::ParseError, 'values_at(): You must provide ' +
+ 'at least one positive index to collect')
+ end
+
+ result = []
+ indices_list = []
+
+ indices.each do |i|
+ i = i.to_s
+ if m = i.match(/^(\d+)(\.\.\.?|\-)(\d+)$/)
+ start = m[1].to_i
+ stop = m[3].to_i
+
+ type = m[2]
+
+ if start > stop
+ raise(Puppet::ParseError, 'values_at(): Stop index in ' +
+ 'given indices range is smaller than the start index')
+ elsif stop > array.size - 1 # First element is at index 0 is it not?
+ raise(Puppet::ParseError, 'values_at(): Stop index in ' +
+ 'given indices range exceeds array size')
+ end
+
+ range = case type
+ when /^(\.\.|\-)$/ then (start .. stop)
+ when /^(\.\.\.)$/ then (start ... stop) # Exclusive of last element ...
+ end
+
+ range.each { |i| indices_list << i.to_i }
+ else
+ # Only positive numbers allowed in this case ...
+ if not i.match(/^\d+$/)
+ raise(Puppet::ParseError, 'values_at(): Unknown format ' +
+ 'of given index')
+ end
+
+ # In Puppet numbers are often string-encoded ...
+ i = i.to_i
+
+ if i > array.size - 1 # Same story. First element is at index 0 ...
+ raise(Puppet::ParseError, 'values_at(): Given index ' +
+ 'exceeds array size')
+ end
+
+ indices_list << i
+ end
+ end
+
+ # We remove nil values as they make no sense in Puppet DSL ...
+ result = indices_list.collect { |i| array[i] }.compact
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+#
+# zip.rb
+#
+
+module Puppet::Parser::Functions
+ newfunction(:zip, :type => :rvalue, :doc => <<-EOS
+Takes one element from first array and merges corresponding elements from second array. This generates a sequence of n-element arrays, where n is one more than the count of arguments.
+
+*Example:*
+
+ zip(['1','2','3'],['4','5','6'])
+
+Would result in:
+
+ ["1", "4"], ["2", "5"], ["3", "6"]
+ EOS
+ ) do |arguments|
+
+ # Technically we support three arguments but only first is mandatory ...
+ raise(Puppet::ParseError, "zip(): Wrong number of arguments " +
+ "given (#{arguments.size} for 2)") if arguments.size < 2
+
+ a = arguments[0]
+ b = arguments[1]
+
+ unless a.is_a?(Array) and b.is_a?(Array)
+ raise(Puppet::ParseError, 'zip(): Requires array to work with')
+ end
+
+ flatten = function_str2bool([arguments[2]]) if arguments[2]
+
+ result = a.zip(b)
+ result = flatten ? result.flatten : result
+
+ return result
+ end
+end
+
+# vim: set ts=2 sw=2 et :
--- /dev/null
+Puppet::Type.type(:file_line).provide(:ruby) do
+ def exists?
+ lines.find do |line|
+ line.chomp == resource[:line].chomp
+ end
+ end
+
+ def create
+ if resource[:match]
+ handle_create_with_match
+ elsif resource[:after]
+ handle_create_with_after
+ else
+ append_line
+ end
+ end
+
+ def destroy
+ local_lines = lines
+ File.open(resource[:path],'w') do |fh|
+ fh.write(local_lines.reject{|l| l.chomp == resource[:line] }.join(''))
+ end
+ end
+
+ private
+ def lines
+ # If this type is ever used with very large files, we should
+ # write this in a different way, using a temp
+ # file; for now assuming that this type is only used on
+ # small-ish config files that can fit into memory without
+ # too much trouble.
+ @lines ||= File.readlines(resource[:path])
+ end
+
+ def handle_create_with_match()
+ regex = resource[:match] ? Regexp.new(resource[:match]) : nil
+ regex_after = resource[:after] ? Regexp.new(resource[:after]) : nil
+ match_count = count_matches(regex)
+
+ if match_count > 1 && resource[:multiple].to_s != 'true'
+ raise Puppet::Error, "More than one line in file '#{resource[:path]}' matches pattern '#{resource[:match]}'"
+ end
+
+ File.open(resource[:path], 'w') do |fh|
+ lines.each do |l|
+ fh.puts(regex.match(l) ? resource[:line] : l)
+ if (match_count == 0 and regex_after)
+ if regex_after.match(l)
+ fh.puts(resource[:line])
+ match_count += 1 #Increment match_count to indicate that the new line has been inserted.
+ end
+ end
+ end
+
+ if (match_count == 0)
+ fh.puts(resource[:line])
+ end
+ end
+ end
+
+ def handle_create_with_after
+ regex = Regexp.new(resource[:after])
+ count = count_matches(regex)
+ case count
+ when 1 # find the line to put our line after
+ File.open(resource[:path], 'w') do |fh|
+ lines.each do |l|
+ fh.puts(l)
+ if regex.match(l) then
+ fh.puts(resource[:line])
+ end
+ end
+ end
+ when 0 # append the line to the end of the file
+ append_line
+ else
+ raise Puppet::Error, "#{count} lines match pattern '#{resource[:after]}' in file '#{resource[:path]}'. One or no line must match the pattern."
+ end
+ end
+
+ def count_matches(regex)
+ lines.select{|l| l.match(regex)}.size
+ end
+
+ ##
+ # append the line to the file.
+ #
+ # @api private
+ def append_line
+ File.open(resource[:path], 'w') do |fh|
+ lines.each do |l|
+ fh.puts(l)
+ end
+ fh.puts resource[:line]
+ end
+ end
+end
--- /dev/null
+Puppet::Type.newtype(:anchor) do
+ desc <<-'ENDOFDESC'
+ A simple resource type intended to be used as an anchor in a composite class.
+
+ In Puppet 2.6, when a class declares another class, the resources in the
+ interior class are not contained by the exterior class. This interacts badly
+ with the pattern of composing complex modules from smaller classes, as it
+ makes it impossible for end users to specify order relationships between the
+ exterior class and other modules.
+
+ The anchor type lets you work around this. By sandwiching any interior
+ classes between two no-op resources that _are_ contained by the exterior
+ class, you can ensure that all resources in the module are contained.
+
+ class ntp {
+ # These classes will have the correct order relationship with each
+ # other. However, without anchors, they won't have any order
+ # relationship to Class['ntp'].
+ class { 'ntp::package': }
+ -> class { 'ntp::config': }
+ -> class { 'ntp::service': }
+
+ # These two resources "anchor" the composed classes within the ntp
+ # class.
+ anchor { 'ntp::begin': } -> Class['ntp::package']
+ Class['ntp::service'] -> anchor { 'ntp::end': }
+ }
+
+ This allows the end user of the ntp module to establish require and before
+ relationships with Class['ntp']:
+
+ class { 'ntp': } -> class { 'mcollective': }
+ class { 'mcollective': } -> class { 'ntp': }
+
+ ENDOFDESC
+
+ newparam :name do
+ desc "The name of the anchor resource."
+ end
+
+ def refresh
+ # We don't do anything with them, but we need this to
+ # show that we are "refresh aware" and not break the
+ # chain of propagation.
+ end
+end
--- /dev/null
+Puppet::Type.newtype(:file_line) do
+
+ desc <<-EOT
+ Ensures that a given line is contained within a file. The implementation
+ matches the full line, including whitespace at the beginning and end. If
+ the line is not contained in the given file, Puppet will append the line to
+ the end of the file to ensure the desired state. Multiple resources may
+ be declared to manage multiple lines in the same file.
+
+ Example:
+
+ file_line { 'sudo_rule':
+ path => '/etc/sudoers',
+ line => '%sudo ALL=(ALL) ALL',
+ }
+
+ file_line { 'sudo_rule_nopw':
+ path => '/etc/sudoers',
+ line => '%sudonopw ALL=(ALL) NOPASSWD: ALL',
+ }
+
+ In this example, Puppet will ensure both of the specified lines are
+ contained in the file /etc/sudoers.
+
+ Match Example:
+
+ file_line { 'bashrc_proxy':
+ ensure => present,
+ path => '/etc/bashrc',
+ line => 'export HTTP_PROXY=http://squid.puppetlabs.vm:3128',
+ match => '^export\ HTTP_PROXY\=',
+ }
+
+ In this code example match will look for a line beginning with export
+ followed by HTTP_PROXY and replace it with the value in line.
+
+ **Autorequires:** If Puppet is managing the file that will contain the line
+ being managed, the file_line resource will autorequire that file.
+
+ EOT
+
+ ensurable do
+ defaultvalues
+ defaultto :present
+ end
+
+ newparam(:name, :namevar => true) do
+ desc 'An arbitrary name used as the identity of the resource.'
+ end
+
+ newparam(:match) do
+ desc 'An optional ruby regular expression to run against existing lines in the file.' +
+ ' If a match is found, we replace that line rather than adding a new line.' +
+ ' A regex comparisson is performed against the line value and if it does not' +
+ ' match an exception will be raised. '
+ end
+
+ newparam(:multiple) do
+ desc 'An optional value to determine if match can change multiple lines.' +
+ ' If set to false, an exception will be raised if more than one line matches'
+ newvalues(true, false)
+ end
+
+ newparam(:after) do
+ desc 'An optional value used to specify the line after which we will add any new lines. (Existing lines are added in place)'
+ end
+
+ newparam(:line) do
+ desc 'The line to be appended to the file or used to replace matches found by the match attribute.'
+ end
+
+ newparam(:path) do
+ desc 'The file Puppet will ensure contains the line specified by the line parameter.'
+ validate do |value|
+ unless (Puppet.features.posix? and value =~ /^\//) or (Puppet.features.microsoft_windows? and (value =~ /^.:\// or value =~ /^\/\/[^\/]+\/[^\/]+/))
+ raise(Puppet::Error, "File paths must be fully qualified, not '#{value}'")
+ end
+ end
+ end
+
+ # Autorequire the file resource if it's being managed
+ autorequire(:file) do
+ self[:path]
+ end
+
+ validate do
+ unless self[:line] and self[:path]
+ raise(Puppet::Error, "Both line and path are required attributes")
+ end
+ end
+end
--- /dev/null
+# Class: stdlib
+#
+# This module manages stdlib. Most of stdlib's features are automatically
+# loaded by Puppet, but this class should be declared in order to use the
+# standardized run stages.
+#
+# Parameters: none
+#
+# Actions:
+#
+# Declares all other classes in the stdlib module. Currently, this consists
+# of stdlib::stages.
+#
+# Requires: nothing
+#
+class stdlib {
+
+ class { 'stdlib::stages': }
+
+}
--- /dev/null
+# Class: stdlib::stages
+#
+# This class manages a standard set of run stages for Puppet. It is managed by
+# the stdlib class, and should not be declared independently.
+#
+# The high level stages are (in order):
+#
+# * setup
+# * main
+# * runtime
+# * setup_infra
+# * deploy_infra
+# * setup_app
+# * deploy_app
+# * deploy
+#
+# Parameters: none
+#
+# Actions:
+#
+# Declares various run-stages for deploying infrastructure,
+# language runtimes, and application layers.
+#
+# Requires: nothing
+#
+# Sample Usage:
+#
+# node default {
+# include stdlib
+# class { java: stage => 'runtime' }
+# }
+#
+class stdlib::stages {
+
+ stage { 'setup': before => Stage['main'] }
+ stage { 'runtime': require => Stage['main'] }
+ -> stage { 'setup_infra': }
+ -> stage { 'deploy_infra': }
+ -> stage { 'setup_app': }
+ -> stage { 'deploy_app': }
+ -> stage { 'deploy': }
+
+}
--- /dev/null
+{
+ "name": "puppetlabs-stdlib",
+ "version": "4.6.0",
+ "author": "puppetlabs",
+ "summary": "Standard library of resources for Puppet modules.",
+ "license": "Apache-2.0",
+ "source": "https://github.com/puppetlabs/puppetlabs-stdlib",
+ "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
+ "issues_url": "https://tickets.puppetlabs.com/browse/MODULES",
+ "operatingsystem_support": [
+ {
+ "operatingsystem": "RedHat",
+ "operatingsystemrelease": [
+ "4",
+ "5",
+ "6",
+ "7"
+ ]
+ },
+ {
+ "operatingsystem": "CentOS",
+ "operatingsystemrelease": [
+ "4",
+ "5",
+ "6",
+ "7"
+ ]
+ },
+ {
+ "operatingsystem": "OracleLinux",
+ "operatingsystemrelease": [
+ "4",
+ "5",
+ "6",
+ "7"
+ ]
+ },
+ {
+ "operatingsystem": "Scientific",
+ "operatingsystemrelease": [
+ "4",
+ "5",
+ "6",
+ "7"
+ ]
+ },
+ {
+ "operatingsystem": "SLES",
+ "operatingsystemrelease": [
+ "10 SP4",
+ "11 SP1",
+ "12"
+ ]
+ },
+ {
+ "operatingsystem": "Debian",
+ "operatingsystemrelease": [
+ "6",
+ "7"
+ ]
+ },
+ {
+ "operatingsystem": "Ubuntu",
+ "operatingsystemrelease": [
+ "10.04",
+ "12.04",
+ "14.04"
+ ]
+ },
+ {
+ "operatingsystem": "Solaris",
+ "operatingsystemrelease": [
+ "10",
+ "11"
+ ]
+ },
+ {
+ "operatingsystem": "Windows",
+ "operatingsystemrelease": [
+ "Server 2003",
+ "Server 2003 R2",
+ "Server 2008",
+ "Server 2008 R2",
+ "Server 2012",
+ "Server 2012 R2",
+ "7",
+ "8"
+ ]
+ },
+ {
+ "operatingsystem": "AIX",
+ "operatingsystemrelease": [
+ "5.3",
+ "6.1",
+ "7.1"
+ ]
+ }
+ ],
+ "requirements": [
+ {
+ "name": "pe",
+ "version_requirement": "3.x"
+ },
+ {
+ "name": "puppet",
+ "version_requirement": ">=2.7.20 <4.0.0"
+ }
+ ],
+ "description": "Standard Library for Puppet Modules",
+ "dependencies": [
+
+ ]
+}
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'abs function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should accept a string' do
+ pp = <<-EOS
+ $input = '-34.56'
+ $output = abs($input)
+ notify { "$output": }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: 34.56/)
+ end
+ end
+
+ it 'should accept a float' do
+ pp = <<-EOS
+ $input = -34.56
+ $output = abs($input)
+ notify { "$output": }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: 34.56/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'any2array function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should create an empty array' do
+ pp = <<-EOS
+ $input = ''
+ $output = any2array($input)
+ validate_array($output)
+ notify { "Output: ${output}": }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: Output: /)
+ end
+ end
+
+ it 'should leave arrays modified' do
+ pp = <<-EOS
+ $input = ['test', 'array']
+ $output = any2array($input)
+ validate_array($output)
+ notify { "Output: ${output}": }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: Output: (\[|)test(,\s|)array(\]|)/)
+ end
+ end
+
+ it 'should turn a hash into an array' do
+ pp = <<-EOS
+ $input = {'test' => 'array'}
+ $output = any2array($input)
+
+ validate_array($output)
+ # Check each element of the array is a plain string.
+ validate_string($output[0])
+ validate_string($output[1])
+ notify { "Output: ${output}": }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: Output: (\[|)test(,\s|)array(\]|)/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'base64 function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should encode then decode a string' do
+ pp = <<-EOS
+ $encodestring = base64('encode', 'thestring')
+ $decodestring = base64('decode', $encodestring)
+ notify { $decodestring: }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/thestring/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'bool2num function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ ['false', 'f', '0', 'n', 'no'].each do |bool|
+ it "should convert a given boolean, #{bool}, to 0" do
+ pp = <<-EOS
+ $input = "#{bool}"
+ $output = bool2num($input)
+ notify { "$output": }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: 0/)
+ end
+ end
+ end
+
+ ['true', 't', '1', 'y', 'yes'].each do |bool|
+ it "should convert a given boolean, #{bool}, to 1" do
+ pp = <<-EOS
+ $input = "#{bool}"
+ $output = bool2num($input)
+ notify { "$output": }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: 1/)
+ end
+ end
+ end
+ end
+end
--- /dev/null
+#!/usr/bin/env ruby
+# vim: set sw=2 sts=2 et tw=80 :
+require 'rspec'
+
+#XXX Super ugly hack to keep from starting beaker nodes
+module Kernel
+ # make an alias of the original require
+ alias_method :original_require, :require
+ # rewrite require
+ def require name
+ original_require name if name != 'spec_helper_acceptance'
+ end
+end
+UNSUPPORTED_PLATFORMS = []
+def fact(*args) [] end
+#XXX End hax
+
+# Get a list of functions for test coverage
+function_list = Dir[File.join(File.dirname(__FILE__),"..","..","lib","puppet","parser","functions","*.rb")].collect do |function_rb|
+ File.basename(function_rb,".rb")
+end
+
+## Configure rspec to parse tests
+options = RSpec::Core::ConfigurationOptions.new(['spec/acceptance'])
+configuration = RSpec::configuration
+world = RSpec::world
+options.parse_options
+options.configure(configuration)
+configuration.load_spec_files
+
+## Collect up tests and example groups into a hash
+def get_tests(children)
+ children.inject({}) do |memo,c|
+ memo[c.description] = Hash.new
+ memo[c.description]["groups"] = get_tests(c.children) unless c.children.empty?
+ memo[c.description]["tests"] = c.examples.collect { |e|
+ e.description unless e.pending?
+ }.compact unless c.examples.empty?
+ memo[c.description]["pending_tests"] = c.examples.collect { |e|
+ e.description if e.pending?
+ }.compact unless c.examples.empty?
+ memo
+ end
+end
+
+def count_test_types_in(type,group)
+ return 0 if group.nil?
+ group.inject(0) do |m,(k,v)|
+ m += v.length if k == type
+ m += count_tests_in(v) if v.is_a?(Hash)
+ m
+ end
+end
+def count_tests_in(group)
+ count_test_types_in('tests',group)
+end
+def count_pending_tests_in(group)
+ count_test_types_in('pending_tests',group)
+end
+
+# Convert tests hash to csv format
+def to_csv(function_list,tests)
+ function_list.collect do |function_name|
+ if v = tests["#{function_name} function"]
+ positive_tests = count_tests_in(v["groups"]["success"])
+ negative_tests = count_tests_in(v["groups"]["failure"])
+ pending_tests =
+ count_pending_tests_in(v["groups"]["failure"]) +
+ count_pending_tests_in(v["groups"]["failure"])
+ else
+ positive_tests = 0
+ negative_tests = 0
+ pending_tests = 0
+ end
+ sprintf("%-25s, %-9d, %-9d, %-9d", function_name,positive_tests,negative_tests,pending_tests)
+ end.compact
+end
+
+tests = get_tests(world.example_groups)
+csv = to_csv(function_list,tests)
+percentage_tested = "#{tests.count*100/function_list.count}%"
+printf("%-25s, %-9s, %-9s, %-9s\n","#{percentage_tested} have tests.","Positive","Negative","Pending")
+puts csv
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'capitalize function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should capitalize the first letter of a string' do
+ pp = <<-EOS
+ $input = 'this is a string'
+ $output = capitalize($input)
+ notify { $output: }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: This is a string/)
+ end
+ end
+
+ it 'should capitalize the first letter of an array of strings' do
+ pp = <<-EOS
+ $input = ['this', 'is', 'a', 'string']
+ $output = capitalize($input)
+ notify { $output: }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: This/)
+ expect(r.stdout).to match(/Notice: Is/)
+ expect(r.stdout).to match(/Notice: A/)
+ expect(r.stdout).to match(/Notice: String/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'ceiling function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'ceilings floats' do
+ pp = <<-EOS
+ $a = 12.8
+ $b = 13
+ $o = ceiling($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'ceilings integers' do
+ pp = <<-EOS
+ $a = 7
+ $b = 7
+ $o = ceiling($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-numbers'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'chomp function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should eat the newline' do
+ pp = <<-EOS
+ $input = "test\n"
+ if size($input) != 5 {
+ fail("Size of ${input} is not 5.")
+ }
+ $output = chomp($input)
+ if size($output) != 4 {
+ fail("Size of ${input} is not 4.")
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'chop function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should eat the last character' do
+ pp = <<-EOS
+ $input = "test"
+ if size($input) != 4 {
+ fail("Size of ${input} is not 4.")
+ }
+ $output = chop($input)
+ if size($output) != 3 {
+ fail("Size of ${input} is not 3.")
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+
+ it 'should eat the last two characters of \r\n' do
+ pp = <<-'EOS'
+ $input = "test\r\n"
+ if size($input) != 6 {
+ fail("Size of ${input} is not 6.")
+ }
+ $output = chop($input)
+ if size($output) != 4 {
+ fail("Size of ${input} is not 4.")
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+
+ it 'should not fail on empty strings' do
+ pp = <<-EOS
+ $input = ""
+ $output = chop($input)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'concat function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should concat one array to another' do
+ pp = <<-EOS
+ $output = concat(['1','2','3'],['4','5','6'])
+ validate_array($output)
+ if size($output) != 6 {
+ fail("${output} should have 6 elements.")
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'should concat arrays and primitives to array' do
+ pp = <<-EOS
+ $output = concat(['1','2','3'],'4','5','6',['7','8','9'])
+ validate_array($output)
+ if size($output) != 9 {
+ fail("${output} should have 9 elements.")
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'should concat multiple arrays to one' do
+ pp = <<-EOS
+ $output = concat(['1','2','3'],['4','5','6'],['7','8','9'])
+ validate_array($output)
+ if size($output) != 9 {
+ fail("${output} should have 9 elements.")
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'count function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should count elements in an array' do
+ pp = <<-EOS
+ $input = [1,2,3,4]
+ $output = count($input)
+ notify { "$output": }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: 4/)
+ end
+ end
+
+ it 'should count elements in an array that match a second argument' do
+ pp = <<-EOS
+ $input = [1,1,1,2]
+ $output = count($input, 1)
+ notify { "$output": }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: 3/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'deep_merge function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should deep merge two hashes' do
+ pp = <<-EOS
+ $hash1 = {'one' => 1, 'two' => 2, 'three' => { 'four' => 4 } }
+ $hash2 = {'two' => 'dos', 'three' => { 'five' => 5 } }
+ $merged_hash = deep_merge($hash1, $hash2)
+
+ if $merged_hash != { 'one' => 1, 'two' => 'dos', 'three' => { 'four' => 4, 'five' => 5 } } {
+ fail("Hash was incorrectly merged.")
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'defined_with_params function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should successfully notify' do
+ pp = <<-EOS
+ user { 'dan':
+ ensure => present,
+ }
+
+ if defined_with_params(User[dan], {'ensure' => 'present' }) {
+ notify { 'User defined with ensure=>present': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: User defined with ensure=>present/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'delete_at function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should delete elements of the array' do
+ pp = <<-EOS
+ $output = delete_at(['a','b','c','b'], 1)
+ if $output == ['a','c','b'] {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'delete function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should delete elements of the array' do
+ pp = <<-EOS
+ $output = delete(['a','b','c','b'], 'b')
+ if $output == ['a','c'] {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'delete_undef_values function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should delete elements of the array' do
+ pp = <<-EOS
+ $output = delete_undef_values({a=>'A', b=>'', c=>undef, d => false})
+ if $output == { a => 'A', b => '', d => false } {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'delete_values function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should delete elements of the hash' do
+ pp = <<-EOS
+ $a = { 'a' => 'A', 'b' => 'B', 'B' => 'C', 'd' => 'B' }
+ $b = { 'a' => 'A', 'B' => 'C' }
+ $o = delete_values($a, 'B')
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles non-hash arguments'
+ it 'handles improper argument counts'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'difference function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'returns non-duplicates in the first array' do
+ pp = <<-EOS
+ $a = ['a','b','c']
+ $b = ['b','c','d']
+ $c = ['a']
+ $o = difference($a, $b)
+ if $o == $c {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles non-array arguments'
+ it 'handles improper argument counts'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'dirname function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ context 'absolute path' do
+ it 'returns the dirname' do
+ pp = <<-EOS
+ $a = '/path/to/a/file.txt'
+ $b = '/path/to/a'
+ $o = dirname($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ context 'relative path' do
+ it 'returns the dirname' do
+ pp = <<-EOS
+ $a = 'path/to/a/file.txt'
+ $b = 'path/to/a'
+ $o = dirname($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'downcase function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'returns the downcase' do
+ pp = <<-EOS
+ $a = 'AOEU'
+ $b = 'aoeu'
+ $o = downcase($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'doesn\'t affect lowercase words' do
+ pp = <<-EOS
+ $a = 'aoeu aoeu'
+ $b = 'aoeu aoeu'
+ $o = downcase($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'empty function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'recognizes empty strings' do
+ pp = <<-EOS
+ $a = ''
+ $b = true
+ $o = empty($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'recognizes non-empty strings' do
+ pp = <<-EOS
+ $a = 'aoeu'
+ $b = false
+ $o = empty($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'ensure_packages function', :unless => fact('osfamily') =~ /windows/i do
+ describe 'success' do
+ it 'ensure_packages a package' do
+ apply_manifest('package { "rake": ensure => absent, provider => "gem", }')
+ pp = <<-EOS
+ $a = "rake"
+ ensure_packages($a,{'provider' => 'gem'})
+ EOS
+
+ apply_manifest(pp, :expect_changes => true)
+ end
+ it 'ensures a package already declared'
+ it 'takes defaults arguments'
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'ensure_resource function', :unless => fact('osfamily') =~ /windows/i do
+ describe 'success' do
+ it 'ensure_resource a package' do
+ apply_manifest('package { "rake": ensure => absent, provider => "gem", }')
+ pp = <<-EOS
+ $a = "rake"
+ ensure_resource('package', $a, {'provider' => 'gem'})
+ EOS
+
+ apply_manifest(pp, :expect_changes => true)
+ end
+ it 'ensures a resource already declared'
+ it 'takes defaults arguments'
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'flatten function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'flattens arrays' do
+ pp = <<-EOS
+ $a = ["a","b",["c",["d","e"],"f","g"]]
+ $b = ["a","b","c","d","e","f","g"]
+ $o = flatten($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'does not affect flat arrays' do
+ pp = <<-EOS
+ $a = ["a","b","c","d","e","f","g"]
+ $b = ["a","b","c","d","e","f","g"]
+ $o = flatten($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'floor function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'floors floats' do
+ pp = <<-EOS
+ $a = 12.8
+ $b = 12
+ $o = floor($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'floors integers' do
+ pp = <<-EOS
+ $a = 7
+ $b = 7
+ $o = floor($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-numbers'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'fqdn_rand_string function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ let(:facts_d) do
+ if fact('is_pe', '--puppet') == "true"
+ if fact('osfamily') =~ /windows/i
+ if fact('kernelmajversion').to_f < 6.0
+ 'c:/documents and settings/all users/application data/puppetlabs/facter/facts.d'
+ else
+ 'c:/programdata/puppetlabs/facter/facts.d'
+ end
+ else
+ '/etc/puppetlabs/facter/facts.d'
+ end
+ else
+ '/etc/facter/facts.d'
+ end
+ end
+ after :each do
+ shell("if [ -f '#{facts_d}/fqdn.txt' ] ; then rm '#{facts_d}/fqdn.txt' ; fi")
+ end
+ before :each do
+ #no need to create on windows, pe creates by default
+ if fact('osfamily') !~ /windows/i
+ shell("mkdir -p '#{facts_d}'")
+ end
+ end
+ it 'generates random alphanumeric strings' do
+ shell("echo fqdn=fakehost.localdomain > '#{facts_d}/fqdn.txt'")
+ pp = <<-eos
+ $l = 10
+ $o = fqdn_rand_string($l)
+ notice(inline_template('fqdn_rand_string is <%= @o.inspect %>'))
+ eos
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/fqdn_rand_string is "7oDp0KOr1b"/)
+ end
+ end
+ it 'generates random alphanumeric strings with custom seeds' do
+ shell("echo fqdn=fakehost.localdomain > '#{facts_d}/fqdn.txt'")
+ pp = <<-eos
+ $l = 10
+ $s = 'seed'
+ $o = fqdn_rand_string($l, undef, $s)
+ notice(inline_template('fqdn_rand_string is <%= @o.inspect %>'))
+ eos
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/fqdn_rand_string is "3HS4mbuI3E"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-numbers for length argument'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'fqdn_rotate function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ let(:facts_d) do
+ if fact('is_pe', '--puppet') == "true"
+ if fact('osfamily') =~ /windows/i
+ if fact('kernelmajversion').to_f < 6.0
+ 'C:/Documents and Settings/All Users/Application Data/PuppetLabs/facter/facts.d'
+ else
+ 'C:/ProgramData/PuppetLabs/facter/facts.d'
+ end
+ else
+ '/etc/puppetlabs/facter/facts.d'
+ end
+ else
+ '/etc/facter/facts.d'
+ end
+ end
+ after :each do
+ shell("if [ -f '#{facts_d}/fqdn.txt' ] ; then rm '#{facts_d}/fqdn.txt' ; fi")
+ end
+ before :each do
+ #No need to create on windows, PE creates by default
+ if fact('osfamily') !~ /windows/i
+ shell("mkdir -p '#{facts_d}'")
+ end
+ end
+ it 'fqdn_rotates floats' do
+ shell("echo fqdn=fakehost.localdomain > '#{facts_d}/fqdn.txt'")
+ pp = <<-EOS
+ $a = ['a','b','c','d']
+ $o = fqdn_rotate($a)
+ notice(inline_template('fqdn_rotate is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/fqdn_rotate is \["c", "d", "a", "b"\]/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-numbers'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'get_module_path function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'get_module_paths dne' do
+ pp = <<-EOS
+ $a = $::is_pe ? {
+ 'true' => '/etc/puppetlabs/puppet/modules/dne',
+ 'false' => '/etc/puppet/modules/dne',
+ }
+ $o = get_module_path('dne')
+ if $o == $a {
+ notify { 'output correct': }
+ } else {
+ notify { "failed; module path is '$o'": }
+ }
+ EOS
+
+ apply_manifest(pp, :expect_failures => true)
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-numbers'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'getparam function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'getparam a notify' do
+ pp = <<-EOS
+ notify { 'rspec':
+ message => 'custom rspec message',
+ }
+ $o = getparam(Notify['rspec'], 'message')
+ notice(inline_template('getparam is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/getparam is "custom rspec message"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'getvar function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'getvars from classes' do
+ pp = <<-EOS
+ class a::data { $foo = 'aoeu' }
+ include a::data
+ $b = 'aoeu'
+ $o = getvar("a::data::foo")
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-numbers'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'grep function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'greps arrays' do
+ pp = <<-EOS
+ $a = ['aaabbb','bbbccc','dddeee']
+ $b = 'bbb'
+ $c = ['aaabbb','bbbccc']
+ $o = grep($a,$b)
+ if $o == $c {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'has_interface_with function', :unless => ((UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem'))) or (fact('osfamily') == 'windows') or (fact('osfamily') == 'AIX')) do
+ describe 'success' do
+ it 'has_interface_with existing ipaddress' do
+ pp = <<-EOS
+ $a = $::ipaddress
+ $o = has_interface_with('ipaddress', $a)
+ notice(inline_template('has_interface_with is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/has_interface_with is true/)
+ end
+ end
+ it 'has_interface_with absent ipaddress' do
+ pp = <<-EOS
+ $a = '128.0.0.1'
+ $o = has_interface_with('ipaddress', $a)
+ notice(inline_template('has_interface_with is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/has_interface_with is false/)
+ end
+ end
+ it 'has_interface_with existing interface' do
+ pp = <<-EOS
+ if $osfamily == 'Solaris' or $osfamily == 'Darwin' {
+ $a = 'lo0'
+ }elsif $osfamily == 'windows' {
+ $a = $::kernelmajversion ? {
+ /6\.(2|3|4)/ => 'Ethernet0',
+ /6\.(0|1)/ => 'Local_Area_Connection',
+ /5\.(1|2)/ => undef, #Broken current in facter
+ }
+ }else {
+ $a = 'lo'
+ }
+ $o = has_interface_with($a)
+ notice(inline_template('has_interface_with is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/has_interface_with is true/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'has_ip_address function', :unless => ((UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem'))) or (fact('osfamily') == 'windows') or (fact('osfamily') == 'AIX')) do
+ describe 'success' do
+ it 'has_ip_address existing ipaddress' do
+ pp = <<-EOS
+ $a = '127.0.0.1'
+ $o = has_ip_address($a)
+ notice(inline_template('has_ip_address is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/has_ip_address is true/)
+ end
+ end
+ it 'has_ip_address absent ipaddress' do
+ pp = <<-EOS
+ $a = '128.0.0.1'
+ $o = has_ip_address($a)
+ notice(inline_template('has_ip_address is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/has_ip_address is false/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'has_ip_network function', :unless => ((UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem'))) or (fact('osfamily') == 'windows') or (fact('osfamily') == 'AIX')) do
+ describe 'success' do
+ it 'has_ip_network existing ipaddress' do
+ pp = <<-EOS
+ $a = '127.0.0.0'
+ $o = has_ip_network($a)
+ notice(inline_template('has_ip_network is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/has_ip_network is true/)
+ end
+ end
+ it 'has_ip_network absent ipaddress' do
+ pp = <<-EOS
+ $a = '128.0.0.0'
+ $o = has_ip_network($a)
+ notice(inline_template('has_ip_network is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/has_ip_network is false/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'has_key function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'has_keys in hashes' do
+ pp = <<-EOS
+ $a = { 'aaa' => 'bbb','bbb' => 'ccc','ddd' => 'eee' }
+ $b = 'bbb'
+ $c = true
+ $o = has_key($a,$b)
+ if $o == $c {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'has_keys not in hashes' do
+ pp = <<-EOS
+ $a = { 'aaa' => 'bbb','bbb' => 'ccc','ddd' => 'eee' }
+ $b = 'ccc'
+ $c = false
+ $o = has_key($a,$b)
+ if $o == $c {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-hashes'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'hash function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'hashs arrays' do
+ pp = <<-EOS
+ $a = ['aaa','bbb','bbb','ccc','ddd','eee']
+ $b = { 'aaa' => 'bbb', 'bbb' => 'ccc', 'ddd' => 'eee' }
+ $o = hash($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'handles odd-length arrays'
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'intersection function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'intersections arrays' do
+ pp = <<-EOS
+ $a = ['aaa','bbb','ccc']
+ $b = ['bbb','ccc','ddd','eee']
+ $c = ['bbb','ccc']
+ $o = intersection($a,$b)
+ if $o == $c {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'intersections empty arrays'
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'is_array function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'is_arrays arrays' do
+ pp = <<-EOS
+ $a = ['aaa','bbb','ccc']
+ $b = true
+ $o = is_array($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_arrays empty arrays' do
+ pp = <<-EOS
+ $a = []
+ $b = true
+ $o = is_array($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_arrays strings' do
+ pp = <<-EOS
+ $a = "aoeu"
+ $b = false
+ $o = is_array($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_arrays hashes' do
+ pp = <<-EOS
+ $a = {'aaa'=>'bbb'}
+ $b = false
+ $o = is_array($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'is_bool function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'is_bools arrays' do
+ pp = <<-EOS
+ $a = ['aaa','bbb','ccc']
+ $b = false
+ $o = is_bool($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_bools true' do
+ pp = <<-EOS
+ $a = true
+ $b = true
+ $o = is_bool($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_bools false' do
+ pp = <<-EOS
+ $a = false
+ $b = true
+ $o = is_bool($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_bools strings' do
+ pp = <<-EOS
+ $a = "true"
+ $b = false
+ $o = is_bool($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_bools hashes' do
+ pp = <<-EOS
+ $a = {'aaa'=>'bbb'}
+ $b = false
+ $o = is_bool($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'is_domain_name function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'is_domain_names arrays' do
+ pp = <<-EOS
+ $a = ['aaa.com','bbb','ccc']
+ $o = is_domain_name($a)
+ notice(inline_template('is_domain_name is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_domain_name is false/)
+ end
+ end
+ it 'is_domain_names true' do
+ pp = <<-EOS
+ $a = true
+ $o = is_domain_name($a)
+ notice(inline_template('is_domain_name is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_domain_name is false/)
+ end
+ end
+ it 'is_domain_names false' do
+ pp = <<-EOS
+ $a = false
+ $o = is_domain_name($a)
+ notice(inline_template('is_domain_name is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_domain_name is false/)
+ end
+ end
+ it 'is_domain_names strings with hyphens' do
+ pp = <<-EOS
+ $a = "3foo-bar.2bar-fuzz.com"
+ $b = true
+ $o = is_domain_name($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_domain_names strings beginning with hyphens' do
+ pp = <<-EOS
+ $a = "-bar.2bar-fuzz.com"
+ $b = false
+ $o = is_domain_name($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_domain_names hashes' do
+ pp = <<-EOS
+ $a = {'aaa'=>'www.com'}
+ $o = is_domain_name($a)
+ notice(inline_template('is_domain_name is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_domain_name is false/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'is_float function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'is_floats arrays' do
+ pp = <<-EOS
+ $a = ['aaa.com','bbb','ccc']
+ $o = is_float($a)
+ notice(inline_template('is_float is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_float is false/)
+ end
+ end
+ it 'is_floats true' do
+ pp = <<-EOS
+ $a = true
+ $o = is_float($a)
+ notice(inline_template('is_float is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_float is false/)
+ end
+ end
+ it 'is_floats strings' do
+ pp = <<-EOS
+ $a = "3.5"
+ $b = true
+ $o = is_float($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_floats floats' do
+ pp = <<-EOS
+ $a = 3.5
+ $b = true
+ $o = is_float($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_floats integers' do
+ pp = <<-EOS
+ $a = 3
+ $b = false
+ $o = is_float($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_floats hashes' do
+ pp = <<-EOS
+ $a = {'aaa'=>'www.com'}
+ $o = is_float($a)
+ notice(inline_template('is_float is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_float is false/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'is_function_available function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'is_function_availables arrays' do
+ pp = <<-EOS
+ $a = ['fail','include','require']
+ $o = is_function_available($a)
+ notice(inline_template('is_function_available is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_function_available is false/)
+ end
+ end
+ it 'is_function_availables true' do
+ pp = <<-EOS
+ $a = true
+ $o = is_function_available($a)
+ notice(inline_template('is_function_available is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_function_available is false/)
+ end
+ end
+ it 'is_function_availables strings' do
+ pp = <<-EOS
+ $a = "fail"
+ $b = true
+ $o = is_function_available($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_function_availables function_availables' do
+ pp = <<-EOS
+ $a = "is_function_available"
+ $o = is_function_available($a)
+ notice(inline_template('is_function_available is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_function_available is true/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'is_hash function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'is_hashs arrays' do
+ pp = <<-EOS
+ $a = ['aaa','bbb','ccc']
+ $o = is_hash($a)
+ notice(inline_template('is_hash is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_hash is false/)
+ end
+ end
+ it 'is_hashs empty hashs' do
+ pp = <<-EOS
+ $a = {}
+ $b = true
+ $o = is_hash($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_hashs strings' do
+ pp = <<-EOS
+ $a = "aoeu"
+ $b = false
+ $o = is_hash($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_hashs hashes' do
+ pp = <<-EOS
+ $a = {'aaa'=>'bbb'}
+ $b = true
+ $o = is_hash($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'is_integer function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'is_integers arrays' do
+ pp = <<-EOS
+ $a = ['aaa.com','bbb','ccc']
+ $b = false
+ $o = is_integer($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_integers true' do
+ pp = <<-EOS
+ $a = true
+ $b = false
+ $o = is_integer($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_integers strings' do
+ pp = <<-EOS
+ $a = "3"
+ $b = true
+ $o = is_integer($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_integers floats' do
+ pp = <<-EOS
+ $a = 3.5
+ $b = false
+ $o = is_integer($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_integers integers' do
+ pp = <<-EOS
+ $a = 3
+ $b = true
+ $o = is_integer($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_integers hashes' do
+ pp = <<-EOS
+ $a = {'aaa'=>'www.com'}
+ $b = false
+ $o = is_integer($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'is_ip_address function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'is_ip_addresss ipv4' do
+ pp = <<-EOS
+ $a = '1.2.3.4'
+ $b = true
+ $o = is_ip_address($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_ip_addresss ipv6' do
+ pp = <<-EOS
+ $a = "fe80:0000:cd12:d123:e2f8:47ff:fe09:dd74"
+ $b = true
+ $o = is_ip_address($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_ip_addresss ipv6 compressed' do
+ pp = <<-EOS
+ $a = "fe00::1"
+ $b = true
+ $o = is_ip_address($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_ip_addresss strings' do
+ pp = <<-EOS
+ $a = "aoeu"
+ $b = false
+ $o = is_ip_address($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_ip_addresss ipv4 out of range' do
+ pp = <<-EOS
+ $a = '1.2.3.400'
+ $b = false
+ $o = is_ip_address($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'is_mac_address function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'is_mac_addresss a mac' do
+ pp = <<-EOS
+ $a = '00:a0:1f:12:7f:a0'
+ $b = true
+ $o = is_mac_address($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_mac_addresss a mac out of range' do
+ pp = <<-EOS
+ $a = '00:a0:1f:12:7f:g0'
+ $b = false
+ $o = is_mac_address($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'is_numeric function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'is_numerics arrays' do
+ pp = <<-EOS
+ $a = ['aaa.com','bbb','ccc']
+ $b = false
+ $o = is_numeric($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_numerics true' do
+ pp = <<-EOS
+ $a = true
+ $b = false
+ $o = is_numeric($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_numerics strings' do
+ pp = <<-EOS
+ $a = "3"
+ $b = true
+ $o = is_numeric($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_numerics floats' do
+ pp = <<-EOS
+ $a = 3.5
+ $b = true
+ $o = is_numeric($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_numerics integers' do
+ pp = <<-EOS
+ $a = 3
+ $b = true
+ $o = is_numeric($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_numerics hashes' do
+ pp = <<-EOS
+ $a = {'aaa'=>'www.com'}
+ $b = false
+ $o = is_numeric($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ it 'handles non-arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'is_string function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'is_strings arrays' do
+ pp = <<-EOS
+ $a = ['aaa.com','bbb','ccc']
+ $b = false
+ $o = is_string($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_strings true' do
+ pp = <<-EOS
+ $a = true
+ $b = false
+ $o = is_string($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_strings strings' do
+ pp = <<-EOS
+ $a = "aoeu"
+ $o = is_string($a)
+ notice(inline_template('is_string is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_string is true/)
+ end
+ end
+ it 'is_strings number strings' do
+ pp = <<-EOS
+ $a = "3"
+ $o = is_string($a)
+ notice(inline_template('is_string is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/is_string is false/)
+ end
+ end
+ it 'is_strings floats' do
+ pp = <<-EOS
+ $a = 3.5
+ $b = false
+ $o = is_string($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_strings integers' do
+ pp = <<-EOS
+ $a = 3
+ $b = false
+ $o = is_string($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'is_strings hashes' do
+ pp = <<-EOS
+ $a = {'aaa'=>'www.com'}
+ $b = false
+ $o = is_string($a)
+ if $o == $b {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'join_keys_to_values function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'join_keys_to_valuess hashes' do
+ pp = <<-EOS
+ $a = {'aaa'=>'bbb','ccc'=>'ddd'}
+ $b = ':'
+ $o = join_keys_to_values($a,$b)
+ notice(inline_template('join_keys_to_values is <%= @o.sort.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/join_keys_to_values is \["aaa:bbb", "ccc:ddd"\]/)
+ end
+ end
+ it 'handles non hashes'
+ it 'handles empty hashes'
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'join function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'joins arrays' do
+ pp = <<-EOS
+ $a = ['aaa','bbb','ccc']
+ $b = ':'
+ $c = 'aaa:bbb:ccc'
+ $o = join($a,$b)
+ if $o == $c {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ it 'handles non arrays'
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'keys function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'keyss hashes' do
+ pp = <<-EOS
+ $a = {'aaa'=>'bbb','ccc'=>'ddd'}
+ $o = keys($a)
+ notice(inline_template('keys is <%= @o.sort.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/keys is \["aaa", "ccc"\]/)
+ end
+ end
+ it 'handles non hashes'
+ it 'handles empty hashes'
+ end
+ describe 'failure' do
+ it 'handles improper argument counts'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+tmpdir = default.tmpdir('stdlib')
+
+describe 'loadyaml function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'loadyamls array of values' do
+ shell("echo '---
+ aaa: 1
+ bbb: 2
+ ccc: 3
+ ddd: 4' > #{tmpdir}/testyaml.yaml")
+ pp = <<-EOS
+ $o = loadyaml('#{tmpdir}/testyaml.yaml')
+ notice(inline_template('loadyaml[aaa] is <%= @o["aaa"].inspect %>'))
+ notice(inline_template('loadyaml[bbb] is <%= @o["bbb"].inspect %>'))
+ notice(inline_template('loadyaml[ccc] is <%= @o["ccc"].inspect %>'))
+ notice(inline_template('loadyaml[ddd] is <%= @o["ddd"].inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/loadyaml\[aaa\] is 1/)
+ expect(r.stdout).to match(/loadyaml\[bbb\] is 2/)
+ expect(r.stdout).to match(/loadyaml\[ccc\] is 3/)
+ expect(r.stdout).to match(/loadyaml\[ddd\] is 4/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'fails with no arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'lstrip function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'lstrips arrays' do
+ pp = <<-EOS
+ $a = [" the "," public "," art","galleries "]
+ # Anagram: Large picture halls, I bet
+ $o = lstrip($a)
+ notice(inline_template('lstrip is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/lstrip is \["the ", "public ", "art", "galleries "\]/)
+ end
+ end
+ it 'lstrips strings' do
+ pp = <<-EOS
+ $a = " blowzy night-frumps vex'd jack q "
+ $o = lstrip($a)
+ notice(inline_template('lstrip is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/lstrip is "blowzy night-frumps vex'd jack q "/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings or arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'max function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'maxs arrays' do
+ pp = <<-EOS
+ $o = max("the","public","art","galleries")
+ notice(inline_template('max is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/max is "the"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'member function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ shared_examples 'item found' do
+ it 'should output correctly' do
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ end
+ describe 'success' do
+ it 'members arrays' do
+ pp = <<-EOS
+ $a = ['aaa','bbb','ccc']
+ $b = 'ccc'
+ $c = true
+ $o = member($a,$b)
+ if $o == $c {
+ notify { 'output correct': }
+ }
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/Notice: output correct/)
+ end
+ end
+ describe 'members array of integers' do
+ it_should_behave_like 'item found' do
+ let(:pp) { <<-EOS
+ if member( [1,2,3,4], 4 ){
+ notify { 'output correct': }
+ }
+ EOS
+ }
+ end
+ end
+ describe 'members of mixed array' do
+ it_should_behave_like 'item found' do
+ let(:pp) { <<-EOS
+ if member( ['a','4',3], 'a' ){
+ notify { 'output correct': }
+}
+ EOS
+ }
+ end
+ end
+ it 'members arrays without members'
+ end
+
+ describe 'failure' do
+ it 'handles improper argument counts'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'merge function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'should merge two hashes' do
+ pp = <<-EOS
+ $a = {'one' => 1, 'two' => 2, 'three' => { 'four' => 4 } }
+ $b = {'two' => 'dos', 'three' => { 'five' => 5 } }
+ $o = merge($a, $b)
+ notice(inline_template('merge[one] is <%= @o["one"].inspect %>'))
+ notice(inline_template('merge[two] is <%= @o["two"].inspect %>'))
+ notice(inline_template('merge[three] is <%= @o["three"].inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/merge\[one\] is ("1"|1)/)
+ expect(r.stdout).to match(/merge\[two\] is "dos"/)
+ expect(r.stdout).to match(/merge\[three\] is {"five"=>("5"|5)}/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'min function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'mins arrays' do
+ pp = <<-EOS
+ $o = min("the","public","art","galleries")
+ notice(inline_template('min is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/min is "art"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ end
+end
--- /dev/null
+HOSTS:
+ centos-59-x64:
+ roles:
+ - master
+ platform: el-5-x86_64
+ box : centos-59-x64-vbox4210-nocm
+ box_url : http://puppet-vagrant-boxes.puppetlabs.com/centos-59-x64-vbox4210-nocm.box
+ hypervisor : vagrant
+CONFIG:
+ type: git
--- /dev/null
+HOSTS:
+ 'centos-6-vcloud':
+ roles:
+ - master
+ platform: el-6-x86_64
+ hypervisor: vcloud
+ template: centos-6-x86_64
+CONFIG:
+ type: foss
+ ssh:
+ keys: "~/.ssh/id_rsa-acceptance"
+ datastore: instance0
+ folder: Delivery/Quality Assurance/Enterprise/Dynamic
+ resourcepool: delivery/Quality Assurance/Enterprise/Dynamic
+ pooling_api: http://vcloud.delivery.puppetlabs.net/
--- /dev/null
+HOSTS:
+ centos-64-x64:
+ roles:
+ - master
+ - database
+ - dashboard
+ platform: el-6-x86_64
+ box : centos-64-x64-vbox4210-nocm
+ box_url : http://puppet-vagrant-boxes.puppetlabs.com/centos-64-x64-vbox4210-nocm.box
+ hypervisor : vagrant
+CONFIG:
+ type: pe
--- /dev/null
+HOSTS:
+ centos-64-x64:
+ roles:
+ - master
+ platform: el-6-x86_64
+ box : centos-64-x64-vbox4210-nocm
+ box_url : http://puppet-vagrant-boxes.puppetlabs.com/centos-64-x64-vbox4210-nocm.box
+ hypervisor : vagrant
+CONFIG:
+ type: foss
--- /dev/null
+HOSTS:
+ centos-65-x64:
+ roles:
+ - master
+ platform: el-6-x86_64
+ box : centos-65-x64-vbox436-nocm
+ box_url : http://puppet-vagrant-boxes.puppetlabs.com/centos-65-x64-virtualbox-nocm.box
+ hypervisor : vagrant
+CONFIG:
+ type: foss
--- /dev/null
+HOSTS:
+ centos-65-x64:
+ roles:
+ - master
+ platform: el-6-x86_64
+ box : centos-65-x64-vbox436-nocm
+ box_url : http://puppet-vagrant-boxes.puppetlabs.com/centos-65-x64-virtualbox-nocm.box
+ hypervisor : vagrant
+CONFIG:
+ type: foss
--- /dev/null
+HOSTS:
+ fedora-18-x64:
+ roles:
+ - master
+ platform: fedora-18-x86_64
+ box : fedora-18-x64-vbox4210-nocm
+ box_url : http://puppet-vagrant-boxes.puppetlabs.com/fedora-18-x64-vbox4210-nocm.box
+ hypervisor : vagrant
+CONFIG:
+ type: foss
--- /dev/null
+HOSTS:
+ sles-11-x64.local:
+ roles:
+ - master
+ platform: sles-11-x64
+ box : sles-11sp1-x64-vbox4210-nocm
+ box_url : http://puppet-vagrant-boxes.puppetlabs.com/sles-11sp1-x64-vbox4210-nocm.box
+ hypervisor : vagrant
+CONFIG:
+ type: foss
--- /dev/null
+HOSTS:
+ ubuntu-server-10044-x64:
+ roles:
+ - master
+ platform: ubuntu-10.04-amd64
+ box : ubuntu-server-10044-x64-vbox4210-nocm
+ box_url : http://puppet-vagrant-boxes.puppetlabs.com/ubuntu-server-10044-x64-vbox4210-nocm.box
+ hypervisor : vagrant
+CONFIG:
+ type: foss
--- /dev/null
+HOSTS:
+ ubuntu-server-12042-x64:
+ roles:
+ - master
+ platform: ubuntu-12.04-amd64
+ box : ubuntu-server-12042-x64-vbox4210-nocm
+ box_url : http://puppet-vagrant-boxes.puppetlabs.com/ubuntu-server-12042-x64-vbox4210-nocm.box
+ hypervisor : vagrant
+CONFIG:
+ type: foss
--- /dev/null
+HOSTS:
+ ubuntu-server-1404-x64:
+ roles:
+ - master
+ platform: ubuntu-14.04-amd64
+ box : puppetlabs/ubuntu-14.04-64-nocm
+ box_url : https://vagrantcloud.com/puppetlabs/ubuntu-14.04-64-nocm
+ hypervisor : vagrant
+CONFIG:
+ log_level : debug
+ type: git
--- /dev/null
+HOSTS:
+ ubuntu1204:
+ roles:
+ - master
+ - database
+ - dashboard
+ platform: ubuntu-12.04-amd64
+ template: ubuntu-1204-x86_64
+ hypervisor: vcloud
+ win2003_i386:
+ roles:
+ - agent
+ - default
+ platform: windows-2003-i386
+ template: win-2003-i386
+ hypervisor: vcloud
+CONFIG:
+ nfs_server: none
+ ssh:
+ keys: "~/.ssh/id_rsa-acceptance"
+ consoleport: 443
+ datastore: instance0
+ folder: Delivery/Quality Assurance/Enterprise/Dynamic
+ resourcepool: delivery/Quality Assurance/Enterprise/Dynamic
+ pooling_api: http://vcloud.delivery.puppetlabs.net/
+ pe_dir: http://neptune.puppetlabs.lan/3.2/ci-ready/
--- /dev/null
+HOSTS:
+ ubuntu1204:
+ roles:
+ - master
+ - database
+ - dashboard
+ platform: ubuntu-12.04-amd64
+ template: ubuntu-1204-x86_64
+ hypervisor: vcloud
+ win2003_x86_64:
+ roles:
+ - agent
+ - default
+ platform: windows-2003-x86_64
+ template: win-2003-x86_64
+ hypervisor: vcloud
+CONFIG:
+ nfs_server: none
+ ssh:
+ keys: "~/.ssh/id_rsa-acceptance"
+ consoleport: 443
+ datastore: instance0
+ folder: Delivery/Quality Assurance/Enterprise/Dynamic
+ resourcepool: delivery/Quality Assurance/Enterprise/Dynamic
+ pooling_api: http://vcloud.delivery.puppetlabs.net/
+ pe_dir: http://neptune.puppetlabs.lan/3.2/ci-ready/
--- /dev/null
+HOSTS:
+ ubuntu1204:
+ roles:
+ - master
+ - database
+ - dashboard
+ platform: ubuntu-12.04-amd64
+ template: ubuntu-1204-x86_64
+ hypervisor: vcloud
+ win2008_x86_64:
+ roles:
+ - agent
+ - default
+ platform: windows-2008-x86_64
+ template: win-2008-x86_64
+ hypervisor: vcloud
+CONFIG:
+ nfs_server: none
+ ssh:
+ keys: "~/.ssh/id_rsa-acceptance"
+ consoleport: 443
+ datastore: instance0
+ folder: Delivery/Quality Assurance/Enterprise/Dynamic
+ resourcepool: delivery/Quality Assurance/Enterprise/Dynamic
+ pooling_api: http://vcloud.delivery.puppetlabs.net/
+ pe_dir: http://neptune.puppetlabs.lan/3.2/ci-ready/
--- /dev/null
+HOSTS:
+ ubuntu1204:
+ roles:
+ - master
+ - database
+ - dashboard
+ platform: ubuntu-12.04-amd64
+ template: ubuntu-1204-x86_64
+ hypervisor: vcloud
+ win2008r2:
+ roles:
+ - agent
+ - default
+ platform: windows-2008r2-x86_64
+ template: win-2008r2-x86_64
+ hypervisor: vcloud
+CONFIG:
+ nfs_server: none
+ ssh:
+ keys: "~/.ssh/id_rsa-acceptance"
+ consoleport: 443
+ datastore: instance0
+ folder: Delivery/Quality Assurance/Enterprise/Dynamic
+ resourcepool: delivery/Quality Assurance/Enterprise/Dynamic
+ pooling_api: http://vcloud.delivery.puppetlabs.net/
+ pe_dir: http://neptune.puppetlabs.lan/3.2/ci-ready/
--- /dev/null
+HOSTS:
+ ubuntu1204:
+ roles:
+ - master
+ - database
+ - dashboard
+ platform: ubuntu-12.04-amd64
+ template: ubuntu-1204-x86_64
+ hypervisor: vcloud
+ win2012:
+ roles:
+ - agent
+ - default
+ platform: windows-2012-x86_64
+ template: win-2012-x86_64
+ hypervisor: vcloud
+CONFIG:
+ nfs_server: none
+ ssh:
+ keys: "~/.ssh/id_rsa-acceptance"
+ consoleport: 443
+ datastore: instance0
+ folder: Delivery/Quality Assurance/Enterprise/Dynamic
+ resourcepool: delivery/Quality Assurance/Enterprise/Dynamic
+ pooling_api: http://vcloud.delivery.puppetlabs.net/
+ pe_dir: http://neptune.puppetlabs.lan/3.2/ci-ready/
--- /dev/null
+HOSTS:
+ ubuntu1204:
+ roles:
+ - master
+ - database
+ - dashboard
+ platform: ubuntu-12.04-amd64
+ template: ubuntu-1204-x86_64
+ hypervisor: vcloud
+ win2012r2:
+ roles:
+ - agent
+ - default
+ platform: windows-2012r2-x86_64
+ template: win-2012r2-x86_64
+ hypervisor: vcloud
+CONFIG:
+ nfs_server: none
+ ssh:
+ keys: "~/.ssh/id_rsa-acceptance"
+ consoleport: 443
+ datastore: instance0
+ folder: Delivery/Quality Assurance/Enterprise/Dynamic
+ resourcepool: delivery/Quality Assurance/Enterprise/Dynamic
+ pooling_api: http://vcloud.delivery.puppetlabs.net/
+ pe_dir: http://neptune.puppetlabs.lan/3.2/ci-ready/
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'num2bool function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'bools positive numbers and numeric strings as true' do
+ pp = <<-EOS
+ $a = 1
+ $b = "1"
+ $c = "50"
+ $ao = num2bool($a)
+ $bo = num2bool($b)
+ $co = num2bool($c)
+ notice(inline_template('a is <%= @ao.inspect %>'))
+ notice(inline_template('b is <%= @bo.inspect %>'))
+ notice(inline_template('c is <%= @co.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/a is true/)
+ expect(r.stdout).to match(/b is true/)
+ expect(r.stdout).to match(/c is true/)
+ end
+ end
+ it 'bools negative numbers as false' do
+ pp = <<-EOS
+ $a = 0
+ $b = -0.1
+ $c = ["-50","1"]
+ $ao = num2bool($a)
+ $bo = num2bool($b)
+ $co = num2bool($c)
+ notice(inline_template('a is <%= @ao.inspect %>'))
+ notice(inline_template('b is <%= @bo.inspect %>'))
+ notice(inline_template('c is <%= @co.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/a is false/)
+ expect(r.stdout).to match(/b is false/)
+ expect(r.stdout).to match(/c is false/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'fails on words' do
+ pp = <<-EOS
+ $a = "a"
+ $ao = num2bool($a)
+ notice(inline_template('a is <%= @ao.inspect %>'))
+ EOS
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/not look like a number/)
+ end
+
+ it 'fails on numberwords' do
+ pp = <<-EOS
+ $b = "1b"
+ $bo = num2bool($b)
+ notice(inline_template('b is <%= @bo.inspect %>'))
+ EOS
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/not look like a number/)
+
+ end
+
+ it 'fails on non-numeric/strings' do
+ pending "The function will call .to_s.to_i on anything not a Numeric or
+ String, and results in 0. Is this intended?"
+ pp = <<-EOS
+ $c = {"c" => "-50"}
+ $co = num2bool($c)
+ notice(inline_template('c is <%= @co.inspect %>'))
+ EOS
+ expect(apply_manifest(ppc :expect_failures => true).stderr).to match(/Unable to parse/)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'parsejson function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'parses valid json' do
+ pp = <<-EOS
+ $a = '{"hunter": "washere", "tests": "passing"}'
+ $ao = parsejson($a)
+ $tests = $ao['tests']
+ notice(inline_template('tests are <%= @tests.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/tests are "passing"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'raises error on incorrect json' do
+ pp = <<-EOS
+ $a = '{"hunter": "washere", "tests": "passing",}'
+ $ao = parsejson($a)
+ notice(inline_template('a is <%= @ao.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :expect_failures => true) do |r|
+ expect(r.stderr).to match(/expected next name/)
+ end
+ end
+
+ it 'raises error on incorrect number of arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'parseyaml function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'parses valid yaml' do
+ pp = <<-EOS
+ $a = "---\nhunter: washere\ntests: passing\n"
+ $o = parseyaml($a)
+ $tests = $o['tests']
+ notice(inline_template('tests are <%= @tests.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/tests are "passing"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'raises error on incorrect yaml' do
+ pp = <<-EOS
+ $a = "---\nhunter: washere\ntests: passing\n:"
+ $o = parseyaml($a)
+ $tests = $o['tests']
+ notice(inline_template('tests are <%= @tests.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :expect_failures => true) do |r|
+ expect(r.stderr).to match(/(syntax error|did not find expected key)/)
+ end
+ end
+
+ it 'raises error on incorrect number of arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'pick_default function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'pick_defaults a default value' do
+ pp = <<-EOS
+ $a = undef
+ $o = pick_default($a, 'default')
+ notice(inline_template('picked is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/picked is "default"/)
+ end
+ end
+ it 'pick_defaults with no value' do
+ pp = <<-EOS
+ $a = undef
+ $b = undef
+ $o = pick_default($a,$b)
+ notice(inline_template('picked is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/picked is ""/)
+ end
+ end
+ it 'pick_defaults the first set value' do
+ pp = <<-EOS
+ $a = "something"
+ $b = "long"
+ $o = pick_default($a, $b, 'default')
+ notice(inline_template('picked is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/picked is "something"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'raises error with no values' do
+ pp = <<-EOS
+ $o = pick_default()
+ notice(inline_template('picked is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :expect_failures => true) do |r|
+ expect(r.stderr).to match(/Must receive at least one argument/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'pick function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'picks a default value' do
+ pp = <<-EOS
+ $a = undef
+ $o = pick($a, 'default')
+ notice(inline_template('picked is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/picked is "default"/)
+ end
+ end
+ it 'picks the first set value' do
+ pp = <<-EOS
+ $a = "something"
+ $b = "long"
+ $o = pick($a, $b, 'default')
+ notice(inline_template('picked is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/picked is "something"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'raises error with all undef values' do
+ pp = <<-EOS
+ $a = undef
+ $b = undef
+ $o = pick($a, $b)
+ notice(inline_template('picked is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :expect_failures => true) do |r|
+ expect(r.stderr).to match(/must receive at least one non empty value/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'prefix function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'prefixes array of values' do
+ pp = <<-EOS
+ $o = prefix(['a','b','c'],'p')
+ notice(inline_template('prefix is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/prefix is \["pa", "pb", "pc"\]/)
+ end
+ end
+ it 'prefixs with empty array' do
+ pp = <<-EOS
+ $o = prefix([],'p')
+ notice(inline_template('prefix is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/prefix is \[\]/)
+ end
+ end
+ it 'prefixs array of values with undef' do
+ pp = <<-EOS
+ $o = prefix(['a','b','c'], undef)
+ notice(inline_template('prefix is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/prefix is \["a", "b", "c"\]/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'fails with no arguments'
+ it 'fails when first argument is not array'
+ it 'fails when second argument is not string'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+# Windows and OS X do not have useful implementations of crypt(3)
+describe 'pw_hash function', :unless => (UNSUPPORTED_PLATFORMS + ['windows', 'Darwin']).include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'hashes passwords' do
+ pp = <<-EOS
+ $o = pw_hash('password', 'sha-512', 'salt')
+ notice(inline_template('pw_hash is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/pw_hash is "\$6\$salt\$IxDD3jeSOb5eB1CX5LBsqZFVkJdido3OUILO5Ifz5iwMuTS4XMS130MTSuDDl3aCI6WouIL9AjRbLCelDCy\.g\."/)
+ end
+ end
+
+ it 'returns nil if no password is provided' do
+ pp = <<-EOS
+ $o = pw_hash('', 'sha-512', 'salt')
+ notice(inline_template('pw_hash is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/pw_hash is nil/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles less than three arguments'
+ it 'handles more than three arguments'
+ it 'handles non strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'range function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'ranges letters' do
+ pp = <<-EOS
+ $o = range('a','d')
+ notice(inline_template('range is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/range is \["a", "b", "c", "d"\]/)
+ end
+ end
+ it 'ranges letters with a step' do
+ pp = <<-EOS
+ $o = range('a','d', '2')
+ notice(inline_template('range is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/range is \["a", "c"\]/)
+ end
+ end
+ it 'ranges letters with a negative step'
+ it 'ranges numbers'
+ it 'ranges numbers with a step'
+ it 'ranges numbers with a negative step'
+ it 'ranges numeric strings'
+ it 'ranges zero padded numbers'
+ end
+ describe 'failure' do
+ it 'fails with no arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'reject function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'rejects array of values' do
+ pp = <<-EOS
+ $o = reject(['aaa','bbb','ccc','aaaddd'], 'aaa')
+ notice(inline_template('reject is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/reject is \["bbb", "ccc"\]/)
+ end
+ end
+ it 'rejects with empty array' do
+ pp = <<-EOS
+ $o = reject([],'aaa')
+ notice(inline_template('reject is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/reject is \[\]/)
+ end
+ end
+ it 'rejects array of values with undef' do
+ pp = <<-EOS
+ $o = reject(['aaa','bbb','ccc','aaaddd'], undef)
+ notice(inline_template('reject is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/reject is \[\]/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'fails with no arguments'
+ it 'fails when first argument is not array'
+ it 'fails when second argument is not string'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'reverse function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'reverses strings' do
+ pp = <<-EOS
+ $a = "the public art galleries"
+ # Anagram: Large picture halls, I bet
+ $o = reverse($a)
+ notice(inline_template('reverse is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/reverse is "seirellag tra cilbup eht"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings or arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'rstrip function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'rstrips arrays' do
+ pp = <<-EOS
+ $a = [" the "," public "," art","galleries "]
+ # Anagram: Large picture halls, I bet
+ $o = rstrip($a)
+ notice(inline_template('rstrip is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/rstrip is \[" the", " public", " art", "galleries"\]/)
+ end
+ end
+ it 'rstrips strings' do
+ pp = <<-EOS
+ $a = " blowzy night-frumps vex'd jack q "
+ $o = rstrip($a)
+ notice(inline_template('rstrip is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/rstrip is " blowzy night-frumps vex'd jack q"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings or arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'shuffle function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'shuffles arrays' do
+ pp = <<-EOS
+ $a = ["1", "2", "3", "4", "5", "6", "7", "8", "the","public","art","galleries"]
+ # Anagram: Large picture halls, I bet
+ $o = shuffle($a)
+ notice(inline_template('shuffle is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to_not match(/shuffle is \["1", "2", "3", "4", "5", "6", "7", "8", "the", "public", "art", "galleries"\]/)
+ end
+ end
+ it 'shuffles strings' do
+ pp = <<-EOS
+ $a = "blowzy night-frumps vex'd jack q"
+ $o = shuffle($a)
+ notice(inline_template('shuffle is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to_not match(/shuffle is "blowzy night-frumps vex'd jack q"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings or arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'size function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'single string size' do
+ pp = <<-EOS
+ $a = 'discombobulate'
+ $o = size($a)
+ notice(inline_template('size is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/size is 14/)
+ end
+ end
+ it 'with empty string' do
+ pp = <<-EOS
+ $a = ''
+ $o = size($a)
+ notice(inline_template('size is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/size is 0/)
+ end
+ end
+ it 'with undef' do
+ pp = <<-EOS
+ $a = undef
+ $o = size($a)
+ notice(inline_template('size is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/size is 0/)
+ end
+ end
+ it 'strings in array' do
+ pp = <<-EOS
+ $a = ['discombobulate', 'moo']
+ $o = size($a)
+ notice(inline_template('size is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/size is 2/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings or arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'sort function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'sorts arrays' do
+ pp = <<-EOS
+ $a = ["the","public","art","galleries"]
+ # Anagram: Large picture halls, I bet
+ $o = sort($a)
+ notice(inline_template('sort is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/sort is \["art", "galleries", "public", "the"\]/)
+ end
+ end
+ it 'sorts strings' do
+ pp = <<-EOS
+ $a = "blowzy night-frumps vex'd jack q"
+ $o = sort($a)
+ notice(inline_template('sort is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/sort is " '-abcdefghijklmnopqrstuvwxyz"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings or arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'squeeze function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'squeezes arrays' do
+ pp = <<-EOS
+ # Real words!
+ $a = ["wallless", "laparohysterosalpingooophorectomy", "brrr", "goddessship"]
+ $o = squeeze($a)
+ notice(inline_template('squeeze is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/squeeze is \["wales", "laparohysterosalpingophorectomy", "br", "godeship"\]/)
+ end
+ end
+ it 'squeezez arrays with an argument'
+ it 'squeezes strings' do
+ pp = <<-EOS
+ $a = "wallless laparohysterosalpingooophorectomy brrr goddessship"
+ $o = squeeze($a)
+ notice(inline_template('squeeze is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/squeeze is "wales laparohysterosalpingophorectomy br godeship"/)
+ end
+ end
+
+ it 'squeezes strings with an argument' do
+ pp = <<-EOS
+ $a = "countessship duchessship governessship hostessship"
+ $o = squeeze($a, 's')
+ notice(inline_template('squeeze is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/squeeze is "counteship ducheship governeship hosteship"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings or arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'str2bool function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'works with "y"' do
+ pp = <<-EOS
+ $o = str2bool('y')
+ notice(inline_template('str2bool is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/str2bool is true/)
+ end
+ end
+ it 'works with "Y"'
+ it 'works with "yes"'
+ it 'works with "1"'
+ it 'works with "true"'
+ it 'works with "n"'
+ it 'works with "N"'
+ it 'works with "no"'
+ it 'works with "0"'
+ it 'works with "false"'
+ it 'works with undef'
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non arrays or strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'str2saltedsha512 function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'works with "y"' do
+ pp = <<-EOS
+ $o = str2saltedsha512('password')
+ notice(inline_template('str2saltedsha512 is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/str2saltedsha512 is "[a-f0-9]{136}"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles more than one argument'
+ it 'handles non strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'strftime function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'gives the Century' do
+ pp = <<-EOS
+ $o = strftime('%C')
+ notice(inline_template('strftime is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/strftime is "20"/)
+ end
+ end
+ it 'takes a timezone argument'
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles invalid format strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'strip function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'strips arrays' do
+ pp = <<-EOS
+ $a = [" the "," public "," art","galleries "]
+ # Anagram: Large picture halls, I bet
+ $o = strip($a)
+ notice(inline_template('strip is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/strip is \["the", "public", "art", "galleries"\]/)
+ end
+ end
+ it 'strips strings' do
+ pp = <<-EOS
+ $a = " blowzy night-frumps vex'd jack q "
+ $o = strip($a)
+ notice(inline_template('strip is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/strip is "blowzy night-frumps vex'd jack q"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings or arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'suffix function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'suffixes array of values' do
+ pp = <<-EOS
+ $o = suffix(['a','b','c'],'p')
+ notice(inline_template('suffix is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/suffix is \["ap", "bp", "cp"\]/)
+ end
+ end
+ it 'suffixs with empty array' do
+ pp = <<-EOS
+ $o = suffix([],'p')
+ notice(inline_template('suffix is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/suffix is \[\]/)
+ end
+ end
+ it 'suffixs array of values with undef' do
+ pp = <<-EOS
+ $o = suffix(['a','b','c'], undef)
+ notice(inline_template('suffix is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/suffix is \["a", "b", "c"\]/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'fails with no arguments'
+ it 'fails when first argument is not array'
+ it 'fails when second argument is not string'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'swapcase function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'works with strings' do
+ pp = <<-EOS
+ $o = swapcase('aBcD')
+ notice(inline_template('swapcase is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/swapcase is "AbCd"/)
+ end
+ end
+ it 'works with arrays'
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non arrays or strings'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'time function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'gives the time' do
+ pp = <<-EOS
+ $o = time()
+ notice(inline_template('time is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ m = r.stdout.match(/time is (\d+)\D/)
+
+ # When I wrote this test
+ expect(Integer(m[1])).to be > 1398894170
+ end
+ end
+ it 'takes a timezone argument' do
+ pp = <<-EOS
+ $o = time('UTC')
+ notice(inline_template('time is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ m = r.stdout.match(/time is (\d+)\D/)
+
+ expect(Integer(m[1])).to be > 1398894170
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles more arguments'
+ it 'handles invalid timezones'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'to_bytes function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'converts kB to B' do
+ pp = <<-EOS
+ $o = to_bytes('4 kB')
+ notice(inline_template('to_bytes is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ m = r.stdout.match(/to_bytes is (\d+)\D/)
+ expect(m[1]).to eq("4096")
+ end
+ end
+ it 'works without the B in unit'
+ it 'works without a space before unit'
+ it 'works without a unit'
+ it 'converts fractions'
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non integer arguments'
+ it 'handles unknown units like uB'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'type function', :unless => (UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) || is_future_parser_enabled?) do
+ describe 'success' do
+ it 'types arrays' do
+ pp = <<-EOS
+ $a = ["the","public","art","galleries"]
+ # Anagram: Large picture halls, I bet
+ $o = type($a)
+ notice(inline_template('type is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/type is "array"/)
+ end
+ end
+ it 'types strings' do
+ pp = <<-EOS
+ $a = "blowzy night-frumps vex'd jack q"
+ $o = type($a)
+ notice(inline_template('type is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/type is "string"/)
+ end
+ end
+ it 'types hashes'
+ it 'types integers'
+ it 'types floats'
+ it 'types booleans'
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'union function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'unions arrays' do
+ pp = <<-EOS
+ $a = ["the","public"]
+ $b = ["art","galleries"]
+ # Anagram: Large picture halls, I bet
+ $o = union($a,$b)
+ notice(inline_template('union is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/union is \["the", "public", "art", "galleries"\]/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'unique function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'uniques arrays' do
+ pp = <<-EOS
+ $a = ["wallless", "wallless", "brrr", "goddessship"]
+ $o = unique($a)
+ notice(inline_template('unique is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/unique is \["wallless", "brrr", "goddessship"\]/)
+ end
+ end
+ it 'uniques strings' do
+ pp = <<-EOS
+ $a = "wallless laparohysterosalpingooophorectomy brrr goddessship"
+ $o = unique($a)
+ notice(inline_template('unique is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/unique is "wales prohytingcmbd"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings or arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'unsupported distributions and OSes', :if => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ it 'should fail' do
+ pp = <<-EOS
+ class { 'mysql::server': }
+ EOS
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/unsupported osfamily/i)
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'upcase function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'upcases arrays' do
+ pp = <<-EOS
+ $a = ["wallless", "laparohysterosalpingooophorectomy", "brrr", "goddessship"]
+ $o = upcase($a)
+ notice(inline_template('upcase is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/upcase is \["WALLLESS", "LAPAROHYSTEROSALPINGOOOPHORECTOMY", "BRRR", "GODDESSSHIP"\]/)
+ end
+ end
+ it 'upcases strings' do
+ pp = <<-EOS
+ $a = "wallless laparohysterosalpingooophorectomy brrr goddessship"
+ $o = upcase($a)
+ notice(inline_template('upcase is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/upcase is "WALLLESS LAPAROHYSTEROSALPINGOOOPHORECTOMY BRRR GODDESSSHIP"/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings or arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'uriescape function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'uriescape strings' do
+ pp = <<-EOS
+ $a = ":/?#[]@!$&'()*+,;= \\\"{}"
+ $o = uriescape($a)
+ notice(inline_template('uriescape is <%= @o.inspect %>'))
+ EOS
+
+ apply_manifest(pp, :catch_failures => true) do |r|
+ expect(r.stdout).to match(/uriescape is ":\/\?%23\[\]@!\$&'\(\)\*\+,;=%20%22%7B%7D"/)
+ end
+ end
+ it 'does nothing if a string is already safe'
+ end
+ describe 'failure' do
+ it 'handles no arguments'
+ it 'handles non strings or arrays'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'validate_absolute_path function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ %w{
+ C:/
+ C:\\\\
+ C:\\\\WINDOWS\\\\System32
+ C:/windows/system32
+ X:/foo/bar
+ X:\\\\foo\\\\bar
+ /var/tmp
+ /var/lib/puppet
+ /var/opt/../lib/puppet
+ }.each do |path|
+ it "validates a single argument #{path}" do
+ pp = <<-EOS
+ $one = '#{path}'
+ validate_absolute_path($one)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments'
+ it 'handles relative paths'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'validate_array function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'validates a single argument' do
+ pp = <<-EOS
+ $one = ['a', 'b']
+ validate_array($one)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates an multiple arguments' do
+ pp = <<-EOS
+ $one = ['a', 'b']
+ $two = [['c'], 'd']
+ validate_array($one,$two)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates a non-array' do
+ {
+ %{validate_array({'a' => 'hash' })} => "Hash",
+ %{validate_array('string')} => "String",
+ %{validate_array(false)} => "FalseClass",
+ %{validate_array(undef)} => "String"
+ }.each do |pp,type|
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/a #{type}/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'validate_augeas function', :unless => ((UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem'))) or (fact('osfamily') == 'windows')) do
+ describe 'prep' do
+ it 'installs augeas for tests'
+ end
+ describe 'success' do
+ context 'valid inputs with no 3rd argument' do
+ {
+ 'root:x:0:0:root:/root:/bin/bash\n' => 'Passwd.lns',
+ 'proc /proc proc nodev,noexec,nosuid 0 0\n' => 'Fstab.lns'
+ }.each do |line,lens|
+ it "validates a single argument for #{lens}" do
+ pp = <<-EOS
+ $line = "#{line}"
+ $lens = "#{lens}"
+ validate_augeas($line, $lens)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ end
+ end
+ context 'valid inputs with 3rd and 4th arguments' do
+ it "validates a restricted value" do
+ line = 'root:x:0:0:root:/root:/bin/barsh\n'
+ lens = 'Passwd.lns'
+ restriction = '$file/*[shell="/bin/barsh"]'
+ pp = <<-EOS
+ $line = "#{line}"
+ $lens = "#{lens}"
+ $restriction = ['#{restriction}']
+ validate_augeas($line, $lens, $restriction, "my custom failure message")
+ EOS
+
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/my custom failure message/)
+ end
+ end
+ context 'invalid inputs' do
+ {
+ 'root:x:0:0:root' => 'Passwd.lns',
+ '127.0.1.1' => 'Hosts.lns'
+ }.each do |line,lens|
+ it "validates a single argument for #{lens}" do
+ pp = <<-EOS
+ $line = "#{line}"
+ $lens = "#{lens}"
+ validate_augeas($line, $lens)
+ EOS
+
+ apply_manifest(pp, :expect_failures => true)
+ end
+ end
+ end
+ context 'garbage inputs' do
+ it 'raises an error on invalid inputs'
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'validate_bool function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'validates a single argument' do
+ pp = <<-EOS
+ $one = true
+ validate_bool($one)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates an multiple arguments' do
+ pp = <<-EOS
+ $one = true
+ $two = false
+ validate_bool($one,$two)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates a non-bool' do
+ {
+ %{validate_bool('true')} => "String",
+ %{validate_bool('false')} => "String",
+ %{validate_bool([true])} => "Array",
+ %{validate_bool(undef)} => "String",
+ }.each do |pp,type|
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/a #{type}/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'validate_cmd function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'validates a true command' do
+ pp = <<-EOS
+ $one = 'foo'
+ if $::osfamily == 'windows' {
+ $two = 'echo' #shell built-in
+ } else {
+ $two = '/bin/echo'
+ }
+ validate_cmd($one,$two)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates a fail command' do
+ pp = <<-EOS
+ $one = 'foo'
+ if $::osfamily == 'windows' {
+ $two = 'C:/aoeu'
+ } else {
+ $two = '/bin/aoeu'
+ }
+ validate_cmd($one,$two)
+ EOS
+
+ apply_manifest(pp, :expect_failures => true)
+ end
+ it 'validates a fail command with a custom error message' do
+ pp = <<-EOS
+ $one = 'foo'
+ if $::osfamily == 'windows' {
+ $two = 'C:/aoeu'
+ } else {
+ $two = '/bin/aoeu'
+ }
+ validate_cmd($one,$two,"aoeu is dvorak")
+ EOS
+
+ apply_manifest(pp, :expect_failures => true) do |output|
+ expect(output.stderr).to match(/aoeu is dvorak/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments'
+ it 'handles improper argument types'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'validate_hash function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'validates a single argument' do
+ pp = <<-EOS
+ $one = { 'a' => 1 }
+ validate_hash($one)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates an multiple arguments' do
+ pp = <<-EOS
+ $one = { 'a' => 1 }
+ $two = { 'b' => 2 }
+ validate_hash($one,$two)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates a non-hash' do
+ {
+ %{validate_hash('{ "not" => "hash" }')} => "String",
+ %{validate_hash('string')} => "String",
+ %{validate_hash(["array"])} => "Array",
+ %{validate_hash(undef)} => "String",
+ }.each do |pp,type|
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/a #{type}/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'validate_ipv4_address function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'validates a single argument' do
+ pp = <<-EOS
+ $one = '1.2.3.4'
+ validate_ipv4_address($one)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates an multiple arguments' do
+ pp = <<-EOS
+ $one = '1.2.3.4'
+ $two = '5.6.7.8'
+ validate_ipv4_address($one,$two)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments'
+ it 'handles ipv6 addresses'
+ it 'handles non-ipv4 strings'
+ it 'handles numbers'
+ it 'handles no arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'validate_ipv6_address function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'validates a single argument' do
+ pp = <<-EOS
+ $one = '3ffe:0505:0002::'
+ validate_ipv6_address($one)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates an multiple arguments' do
+ pp = <<-EOS
+ $one = '3ffe:0505:0002::'
+ $two = '3ffe:0505:0001::'
+ validate_ipv6_address($one,$two)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments'
+ it 'handles ipv6 addresses'
+ it 'handles non-ipv6 strings'
+ it 'handles numbers'
+ it 'handles no arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'validate_re function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'validates a string' do
+ pp = <<-EOS
+ $one = 'one'
+ $two = '^one$'
+ validate_re($one,$two)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates an array' do
+ pp = <<-EOS
+ $one = 'one'
+ $two = ['^one$', '^two']
+ validate_re($one,$two)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates a failed array' do
+ pp = <<-EOS
+ $one = 'one'
+ $two = ['^two$', '^three']
+ validate_re($one,$two)
+ EOS
+
+ apply_manifest(pp, :expect_failures => true)
+ end
+ it 'validates a failed array with a custom error message' do
+ pp = <<-EOS
+ $one = '3.4.3'
+ $two = '^2.7'
+ validate_re($one,$two,"The $puppetversion fact does not match 2.7")
+ EOS
+
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/does not match/)
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments'
+ it 'handles improper argument types'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'validate_slength function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'validates a single string max' do
+ pp = <<-EOS
+ $one = 'discombobulate'
+ $two = 17
+ validate_slength($one,$two)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates multiple string maxes' do
+ pp = <<-EOS
+ $one = ['discombobulate', 'moo']
+ $two = 17
+ validate_slength($one,$two)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates min/max of strings in array' do
+ pp = <<-EOS
+ $one = ['discombobulate', 'moo']
+ $two = 17
+ $three = 3
+ validate_slength($one,$two,$three)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates a single string max of incorrect length' do
+ pp = <<-EOS
+ $one = 'discombobulate'
+ $two = 1
+ validate_slength($one,$two)
+ EOS
+
+ apply_manifest(pp, :expect_failures => true)
+ end
+ it 'validates multiple string maxes of incorrect length' do
+ pp = <<-EOS
+ $one = ['discombobulate', 'moo']
+ $two = 3
+ validate_slength($one,$two)
+ EOS
+
+ apply_manifest(pp, :expect_failures => true)
+ end
+ it 'validates multiple strings min/maxes of incorrect length' do
+ pp = <<-EOS
+ $one = ['discombobulate', 'moo']
+ $two = 17
+ $three = 10
+ validate_slength($one,$two,$three)
+ EOS
+
+ apply_manifest(pp, :expect_failures => true)
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments'
+ it 'handles improper first argument type'
+ it 'handles non-strings in array of first argument'
+ it 'handles improper second argument type'
+ it 'handles improper third argument type'
+ it 'handles negative ranges'
+ it 'handles improper ranges'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'validate_string function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'validates a single argument' do
+ pp = <<-EOS
+ $one = 'string'
+ validate_string($one)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates an multiple arguments' do
+ pp = <<-EOS
+ $one = 'string'
+ $two = 'also string'
+ validate_string($one,$two)
+ EOS
+
+ apply_manifest(pp, :catch_failures => true)
+ end
+ it 'validates a non-string' do
+ {
+ %{validate_string({ 'a' => 'hash' })} => "Hash",
+ %{validate_string(['array'])} => "Array",
+ %{validate_string(false)} => "FalseClass",
+ }.each do |pp,type|
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/a #{type}/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'values_at function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'returns a specific value' do
+ pp = <<-EOS
+ $one = ['a','b','c','d','e']
+ $two = 1
+ $output = values_at($one,$two)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["b"\]/)
+ end
+ it 'returns a specific negative index value' do
+ pending("negative numbers don't work")
+ pp = <<-EOS
+ $one = ['a','b','c','d','e']
+ $two = -1
+ $output = values_at($one,$two)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["e"\]/)
+ end
+ it 'returns a range of values' do
+ pp = <<-EOS
+ $one = ['a','b','c','d','e']
+ $two = "1-3"
+ $output = values_at($one,$two)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["b", "c", "d"\]/)
+ end
+ it 'returns a negative specific value and range of values' do
+ pp = <<-EOS
+ $one = ['a','b','c','d','e']
+ $two = ["1-3",0]
+ $output = values_at($one,$two)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["b", "c", "d", "a"\]/)
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments' do
+ pp = <<-EOS
+ $one = ['a','b','c','d','e']
+ $output = values_at($one)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/Wrong number of arguments/)
+ end
+ it 'handles non-indicies arguments' do
+ pp = <<-EOS
+ $one = ['a','b','c','d','e']
+ $two = []
+ $output = values_at($one,$two)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/at least one positive index/)
+ end
+
+ it 'detects index ranges smaller than the start range'
+ it 'handles index ranges larger than array'
+ it 'handles non-integer indicies'
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+
+describe 'values function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'returns an array of values' do
+ pp = <<-EOS
+ $arg = {
+ 'a' => 1,
+ 'b' => 2,
+ 'c' => 3,
+ }
+ $output = values($arg)
+ notice(inline_template('<%= @output.sort.inspect %>'))
+ EOS
+ if is_future_parser_enabled?
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[1, 2, 3\]/)
+ else
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["1", "2", "3"\]/)
+ end
+
+ end
+ end
+ describe 'failure' do
+ it 'handles non-hash arguments' do
+ pp = <<-EOS
+ $arg = "foo"
+ $output = values($arg)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/Requires hash/)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper_acceptance'
+require 'puppet'
+
+describe 'zip function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
+ describe 'success' do
+ it 'zips two arrays of numbers together' do
+ pp = <<-EOS
+ $one = [1,2,3,4]
+ $two = [5,6,7,8]
+ $output = zip($one,$two)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+ if is_future_parser_enabled?
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\[1, 5\], \[2, 6\], \[3, 7\], \[4, 8\]\]/)
+ else
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\["1", "5"\], \["2", "6"\], \["3", "7"\], \["4", "8"\]\]/)
+ end
+ end
+ it 'zips two arrays of numbers & bools together' do
+ pp = <<-EOS
+ $one = [1,2,"three",4]
+ $two = [true,true,false,false]
+ $output = zip($one,$two)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+ if is_future_parser_enabled?
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\[1, true\], \[2, true\], \["three", false\], \[4, false\]\]/)
+ else
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\["1", true\], \["2", true\], \["three", false\], \["4", false\]\]/)
+ end
+ end
+ it 'zips two arrays of numbers together and flattens them' do
+ # XXX This only tests the argument `true`, even though the following are valid:
+ # 1 t y true yes
+ # 0 f n false no
+ # undef undefined
+ pp = <<-EOS
+ $one = [1,2,3,4]
+ $two = [5,6,7,8]
+ $output = zip($one,$two,true)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+ if is_future_parser_enabled?
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[1, 5, 2, 6, 3, 7, 4, 8\]/)
+ else
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["1", "5", "2", "6", "3", "7", "4", "8"\]/)
+ end
+ end
+ it 'handles unmatched length' do
+ # XXX Is this expected behavior?
+ pp = <<-EOS
+ $one = [1,2]
+ $two = [5,6,7,8]
+ $output = zip($one,$two)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+ if is_future_parser_enabled?
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\[1, 5\], \[2, 6\]\]/)
+ else
+ expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\["1", "5"\], \["2", "6"\]\]/)
+ end
+ end
+ end
+ describe 'failure' do
+ it 'handles improper number of arguments' do
+ pp = <<-EOS
+ $one = [1,2]
+ $output = zip($one)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/Wrong number of arguments/)
+ end
+ it 'handles improper argument types' do
+ pp = <<-EOS
+ $one = "a string"
+ $two = [5,6,7,8]
+ $output = zip($one,$two)
+ notice(inline_template('<%= @output.inspect %>'))
+ EOS
+
+ expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/Requires array/)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe "anchorrefresh" do
+ include PuppetSpec::Compiler
+
+ let :transaction do
+ apply_compiled_manifest(<<-ANCHORCLASS)
+ class anchored {
+ anchor { 'anchored::begin': }
+ ~> anchor { 'anchored::end': }
+ }
+
+ class anchorrefresh {
+ notify { 'first': }
+ ~> class { 'anchored': }
+ ~> anchor { 'final': }
+ }
+
+ include anchorrefresh
+ ANCHORCLASS
+ end
+
+ it 'propagates events through the anchored class' do
+ resource = transaction.resource_status('Anchor[final]')
+
+ expect(resource.restarted).to eq(true)
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the abs function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("abs")).to eq("function_abs")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_abs([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should convert a negative number into a positive" do
+ result = scope.function_abs(["-34"])
+ expect(result).to(eq(34))
+ end
+
+ it "should do nothing with a positive number" do
+ result = scope.function_abs(["5678"])
+ expect(result).to(eq(5678))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the any2array function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("any2array")).to eq("function_any2array")
+ end
+
+ it "should return an empty array if there is less than 1 argument" do
+ result = scope.function_any2array([])
+ expect(result).to(eq([]))
+ end
+
+ it "should convert boolean true to [ true ] " do
+ result = scope.function_any2array([true])
+ expect(result).to(eq([true]))
+ end
+
+ it "should convert one object to [object]" do
+ result = scope.function_any2array(['one'])
+ expect(result).to(eq(['one']))
+ end
+
+ it "should convert multiple objects to [objects]" do
+ result = scope.function_any2array(['one', 'two'])
+ expect(result).to(eq(['one', 'two']))
+ end
+
+ it "should return empty array it was called with" do
+ result = scope.function_any2array([[]])
+ expect(result).to(eq([]))
+ end
+
+ it "should return one-member array it was called with" do
+ result = scope.function_any2array([['string']])
+ expect(result).to(eq(['string']))
+ end
+
+ it "should return multi-member array it was called with" do
+ result = scope.function_any2array([['one', 'two']])
+ expect(result).to(eq(['one', 'two']))
+ end
+
+ it "should return members of a hash it was called with" do
+ result = scope.function_any2array([{ 'key' => 'value' }])
+ expect(result).to(eq(['key', 'value']))
+ end
+
+ it "should return an empty array if it was called with an empty hash" do
+ result = scope.function_any2array([{ }])
+ expect(result).to(eq([]))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:assert_private) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ subject do
+ function_name = Puppet::Parser::Functions.function(:assert_private)
+ scope.method(function_name)
+ end
+
+ context "when called from inside module" do
+ it "should not fail" do
+ scope.expects(:lookupvar).with('module_name').returns('foo')
+ scope.expects(:lookupvar).with('caller_module_name').returns('foo')
+ expect {
+ subject.call []
+ }.not_to raise_error
+ end
+ end
+
+ context "with an explicit failure message" do
+ it "prints the failure message on error" do
+ scope.expects(:lookupvar).with('module_name').returns('foo')
+ scope.expects(:lookupvar).with('caller_module_name').returns('bar')
+ expect {
+ subject.call ['failure message!']
+ }.to raise_error Puppet::ParseError, /failure message!/
+ end
+ end
+
+ context "when called from private class" do
+ it "should fail with a class error message" do
+ scope.expects(:lookupvar).with('module_name').returns('foo')
+ scope.expects(:lookupvar).with('caller_module_name').returns('bar')
+ scope.source.expects(:name).returns('foo::baz')
+ scope.source.expects(:type).returns('hostclass')
+ expect {
+ subject.call []
+ }.to raise_error Puppet::ParseError, /Class foo::baz is private/
+ end
+ end
+
+ context "when called from private definition" do
+ it "should fail with a class error message" do
+ scope.expects(:lookupvar).with('module_name').returns('foo')
+ scope.expects(:lookupvar).with('caller_module_name').returns('bar')
+ scope.source.expects(:name).returns('foo::baz')
+ scope.source.expects(:type).returns('definition')
+ expect {
+ subject.call []
+ }.to raise_error Puppet::ParseError, /Definition foo::baz is private/
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the base64 function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("base64")).to eq("function_base64")
+ end
+
+ it "should raise a ParseError if there are other than 2 arguments" do
+ expect { scope.function_base64([]) }.to(raise_error(Puppet::ParseError))
+ expect { scope.function_base64(["asdf"]) }.to(raise_error(Puppet::ParseError))
+ expect { scope.function_base64(["asdf","moo","cow"]) }.to(raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a ParseError if argument 1 isn't 'encode' or 'decode'" do
+ expect { scope.function_base64(["bees","astring"]) }.to(raise_error(Puppet::ParseError, /first argument must be one of/))
+ end
+
+ it "should raise a ParseError if argument 2 isn't a string" do
+ expect { scope.function_base64(["encode",["2"]]) }.to(raise_error(Puppet::ParseError, /second argument must be a string/))
+ end
+
+ it "should encode a encoded string" do
+ result = scope.function_base64(["encode",'thestring'])
+ expect(result).to match(/\AdGhlc3RyaW5n\n\Z/)
+ end
+ it "should decode a base64 encoded string" do
+ result = scope.function_base64(["decode",'dGhlc3RyaW5n'])
+ expect(result).to eq('thestring')
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the bool2num function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("bool2num")).to eq("function_bool2num")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_bool2num([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should convert true to 1" do
+ result = scope.function_bool2num([true])
+ expect(result).to(eq(1))
+ end
+
+ it "should convert 'true' to 1" do
+ result = scope.function_bool2num(['true'])
+ result.should(eq(1))
+ end
+
+ it "should convert 'false' to 0" do
+ result = scope.function_bool2num(['false'])
+ expect(result).to(eq(0))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new('true')
+ result = scope.function_bool2num([value])
+ result.should(eq(1))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the capitalize function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("capitalize")).to eq("function_capitalize")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_capitalize([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should capitalize the beginning of a string" do
+ result = scope.function_capitalize(["abc"])
+ expect(result).to(eq("Abc"))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new('abc')
+ result = scope.function_capitalize([value])
+ result.should(eq('Abc'))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the ceiling function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("ceiling")).to eq("function_ceiling")
+ end
+
+ it "should raise a ParseError if there is less than 1 argument" do
+ expect { scope.function_ceiling([]) }.to( raise_error(Puppet::ParseError, /Wrong number of arguments/))
+ end
+
+ it "should should raise a ParseError if input isn't numeric (eg. String)" do
+ expect { scope.function_ceiling(["foo"]) }.to( raise_error(Puppet::ParseError, /Wrong argument type/))
+ end
+
+ it "should should raise a ParseError if input isn't numeric (eg. Boolean)" do
+ expect { scope.function_ceiling([true]) }.to( raise_error(Puppet::ParseError, /Wrong argument type/))
+ end
+
+ it "should return an integer when a numeric type is passed" do
+ result = scope.function_ceiling([12.4])
+ expect(result.is_a?(Integer)).to(eq(true))
+ end
+
+ it "should return the input when an integer is passed" do
+ result = scope.function_ceiling([7])
+ expect(result).to(eq(7))
+ end
+
+ it "should return the smallest integer greater than or equal to the input" do
+ result = scope.function_ceiling([3.8])
+ expect(result).to(eq(4))
+ end
+end
+
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the chomp function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("chomp")).to eq("function_chomp")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_chomp([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should chomp the end of a string" do
+ result = scope.function_chomp(["abc\n"])
+ expect(result).to(eq("abc"))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new("abc\n")
+ result = scope.function_chomp([value])
+ result.should(eq("abc"))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the chop function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("chop")).to eq("function_chop")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_chop([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should chop the end of a string" do
+ result = scope.function_chop(["asdf\n"])
+ expect(result).to(eq("asdf"))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new("abc\n")
+ result = scope.function_chop([value])
+ result.should(eq('abc'))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the concat function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should raise a ParseError if the client does not provide at least two arguments" do
+ expect { scope.function_concat([]) }.to(raise_error(Puppet::ParseError))
+ expect { scope.function_concat([[1]]) }.to(raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a ParseError if the first parameter is not an array" do
+ expect { scope.function_concat([1, []])}.to(raise_error(Puppet::ParseError))
+ end
+
+ it "should not raise a ParseError if the client provides more than two arguments" do
+ expect { scope.function_concat([[1],[2],[3]]) }.not_to raise_error
+ end
+
+ it "should be able to concat an array" do
+ result = scope.function_concat([['1','2','3'],['4','5','6']])
+ expect(result).to(eq(['1','2','3','4','5','6']))
+ end
+
+ it "should be able to concat a primitive to an array" do
+ result = scope.function_concat([['1','2','3'],'4'])
+ expect(result).to(eq(['1','2','3','4']))
+ end
+
+ it "should not accidentally flatten nested arrays" do
+ result = scope.function_concat([['1','2','3'],[['4','5'],'6']])
+ expect(result).to(eq(['1','2','3',['4','5'],'6']))
+ end
+
+ it "should leave the original array intact" do
+ array_original = ['1','2','3']
+ result = scope.function_concat([array_original,['4','5','6']])
+ array_original.should(eq(['1','2','3']))
+ end
+
+ it "should be able to concat multiple arrays" do
+ result = scope.function_concat([['1','2','3'],['4','5','6'],['7','8','9']])
+ expect(result).to(eq(['1','2','3','4','5','6','7','8','9']))
+ end
+
+ it "should be able to concat mix of primitives and arrays to a final array" do
+ result = scope.function_concat([['1','2','3'],'4',['5','6','7']])
+ expect(result).to(eq(['1','2','3','4','5','6','7']))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the count function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("count")).to eq("function_count")
+ end
+
+ it "should raise a ArgumentError if there is more than 2 arguments" do
+ expect { scope.function_count(['foo', 'bar', 'baz']) }.to( raise_error(ArgumentError))
+ end
+
+ it "should be able to count arrays" do
+ expect(scope.function_count([["1","2","3"]])).to(eq(3))
+ end
+
+ it "should be able to count matching elements in arrays" do
+ expect(scope.function_count([["1", "2", "2"], "2"])).to(eq(2))
+ end
+
+ it "should not count nil or empty strings" do
+ expect(scope.function_count([["foo","bar",nil,""]])).to(eq(2))
+ end
+
+ it 'does not count an undefined hash key or an out of bound array index (which are both :undef)' do
+ expect(scope.function_count([["foo",:undef,:undef]])).to eq(1)
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:deep_merge) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ describe 'when calling deep_merge from puppet' do
+ it "should not compile when no arguments are passed" do
+ skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+ Puppet[:code] = '$x = deep_merge()'
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+ end
+
+ it "should not compile when 1 argument is passed" do
+ skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+ Puppet[:code] = "$my_hash={'one' => 1}\n$x = deep_merge($my_hash)"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+ end
+ end
+
+ describe 'when calling deep_merge on the scope instance' do
+ it 'should require all parameters are hashes' do
+ expect { new_hash = scope.function_deep_merge([{}, '2'])}.to raise_error(Puppet::ParseError, /unexpected argument type String/)
+ expect { new_hash = scope.function_deep_merge([{}, 2])}.to raise_error(Puppet::ParseError, /unexpected argument type Fixnum/)
+ end
+
+ it 'should accept empty strings as puppet undef' do
+ expect { new_hash = scope.function_deep_merge([{}, ''])}.not_to raise_error
+ end
+
+ it 'should be able to deep_merge two hashes' do
+ new_hash = scope.function_deep_merge([{'one' => '1', 'two' => '1'}, {'two' => '2', 'three' => '2'}])
+ expect(new_hash['one']).to eq('1')
+ expect(new_hash['two']).to eq('2')
+ expect(new_hash['three']).to eq('2')
+ end
+
+ it 'should deep_merge multiple hashes' do
+ hash = scope.function_deep_merge([{'one' => 1}, {'one' => '2'}, {'one' => '3'}])
+ expect(hash['one']).to eq('3')
+ end
+
+ it 'should accept empty hashes' do
+ expect(scope.function_deep_merge([{},{},{}])).to eq({})
+ end
+
+ it 'should deep_merge subhashes' do
+ hash = scope.function_deep_merge([{'one' => 1}, {'two' => 2, 'three' => { 'four' => 4 } }])
+ expect(hash['one']).to eq(1)
+ expect(hash['two']).to eq(2)
+ expect(hash['three']).to eq({ 'four' => 4 })
+ end
+
+ it 'should append to subhashes' do
+ hash = scope.function_deep_merge([{'one' => { 'two' => 2 } }, { 'one' => { 'three' => 3 } }])
+ expect(hash['one']).to eq({ 'two' => 2, 'three' => 3 })
+ end
+
+ it 'should append to subhashes 2' do
+ hash = scope.function_deep_merge([{'one' => 1, 'two' => 2, 'three' => { 'four' => 4 } }, {'two' => 'dos', 'three' => { 'five' => 5 } }])
+ expect(hash['one']).to eq(1)
+ expect(hash['two']).to eq('dos')
+ expect(hash['three']).to eq({ 'four' => 4, 'five' => 5 })
+ end
+
+ it 'should append to subhashes 3' do
+ hash = scope.function_deep_merge([{ 'key1' => { 'a' => 1, 'b' => 2 }, 'key2' => { 'c' => 3 } }, { 'key1' => { 'b' => 99 } }])
+ expect(hash['key1']).to eq({ 'a' => 1, 'b' => 99 })
+ expect(hash['key2']).to eq({ 'c' => 3 })
+ end
+
+ it 'should not change the original hashes' do
+ hash1 = {'one' => { 'two' => 2 } }
+ hash2 = { 'one' => { 'three' => 3 } }
+ hash = scope.function_deep_merge([hash1, hash2])
+ expect(hash1).to eq({'one' => { 'two' => 2 } })
+ expect(hash2).to eq({ 'one' => { 'three' => 3 } })
+ expect(hash['one']).to eq({ 'two' => 2, 'three' => 3 })
+ end
+
+ it 'should not change the original hashes 2' do
+ hash1 = {'one' => { 'two' => [1,2] } }
+ hash2 = { 'one' => { 'three' => 3 } }
+ hash = scope.function_deep_merge([hash1, hash2])
+ expect(hash1).to eq({'one' => { 'two' => [1,2] } })
+ expect(hash2).to eq({ 'one' => { 'three' => 3 } })
+ expect(hash['one']).to eq({ 'two' => [1,2], 'three' => 3 })
+ end
+
+ it 'should not change the original hashes 3' do
+ hash1 = {'one' => { 'two' => [1,2, {'two' => 2} ] } }
+ hash2 = { 'one' => { 'three' => 3 } }
+ hash = scope.function_deep_merge([hash1, hash2])
+ expect(hash1).to eq({'one' => { 'two' => [1,2, {'two' => 2}] } })
+ expect(hash2).to eq({ 'one' => { 'three' => 3 } })
+ expect(hash['one']).to eq({ 'two' => [1,2, {'two' => 2} ], 'three' => 3 })
+ expect(hash['one']['two']).to eq([1,2, {'two' => 2}])
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+require 'rspec-puppet'
+describe 'defined_with_params' do
+ describe 'when a resource is not specified' do
+ it { is_expected.to run.with_params().and_raise_error(ArgumentError) }
+ end
+ describe 'when compared against a resource with no attributes' do
+ let :pre_condition do
+ 'user { "dan": }'
+ end
+ it do
+ is_expected.to run.with_params('User[dan]', {}).and_return(true)
+ is_expected.to run.with_params('User[bob]', {}).and_return(false)
+ is_expected.to run.with_params('User[dan]', {'foo' => 'bar'}).and_return(false)
+ end
+ end
+
+ describe 'when compared against a resource with attributes' do
+ let :pre_condition do
+ 'user { "dan": ensure => present, shell => "/bin/csh", managehome => false}'
+ end
+ it do
+ is_expected.to run.with_params('User[dan]', {}).and_return(true)
+ is_expected.to run.with_params('User[dan]', '').and_return(true)
+ is_expected.to run.with_params('User[dan]', {'ensure' => 'present'}
+ ).and_return(true)
+ is_expected.to run.with_params('User[dan]',
+ {'ensure' => 'present', 'managehome' => false}
+ ).and_return(true)
+ is_expected.to run.with_params('User[dan]',
+ {'ensure' => 'absent', 'managehome' => false}
+ ).and_return(false)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the delete_at function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("delete_at")).to eq("function_delete_at")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_delete_at([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should delete an item at specified location from an array" do
+ result = scope.function_delete_at([['a','b','c'],1])
+ expect(result).to(eq(['a','c']))
+ end
+
+ it "should not change origin array passed as argument" do
+ origin_array = ['a','b','c','d']
+ result = scope.function_delete_at([origin_array, 1])
+ expect(origin_array).to(eq(['a','b','c','d']))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the delete function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("delete")).to eq("function_delete")
+ end
+
+ it "should raise a ParseError if there are fewer than 2 arguments" do
+ expect { scope.function_delete([]) }.to(raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a ParseError if there are greater than 2 arguments" do
+ expect { scope.function_delete([[], 'foo', 'bar']) }.to(raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a TypeError if a number is passed as the first argument" do
+ expect { scope.function_delete([1, 'bar']) }.to(raise_error(TypeError))
+ end
+
+ it "should delete all instances of an element from an array" do
+ result = scope.function_delete([['a', 'b', 'c', 'b'], 'b'])
+ expect(result).to(eq(['a', 'c']))
+ end
+
+ it "should delete all instances of a substring from a string" do
+ result = scope.function_delete(['foobarbabarz', 'bar'])
+ expect(result).to(eq('foobaz'))
+ end
+
+ it "should delete a key from a hash" do
+ result = scope.function_delete([{'a' => 1, 'b' => 2, 'c' => 3}, 'b'])
+ expect(result).to(eq({'a' => 1, 'c' => 3}))
+ end
+
+ it 'should accept an array of items to delete' do
+ result = scope.function_delete([{'a' => 1, 'b' => 2, 'c' => 3}, ['b', 'c']])
+ expect(result).to(eq({'a' => 1}))
+ end
+
+ it "should not change origin array passed as argument" do
+ origin_array = ['a', 'b', 'c', 'd']
+ result = scope.function_delete([origin_array, 'b'])
+ expect(origin_array).to(eq(['a', 'b', 'c', 'd']))
+ end
+
+ it "should not change the origin string passed as argument" do
+ origin_string = 'foobarbabarz'
+ result = scope.function_delete([origin_string, 'bar'])
+ expect(origin_string).to(eq('foobarbabarz'))
+ end
+
+ it "should not change origin hash passed as argument" do
+ origin_hash = {'a' => 1, 'b' => 2, 'c' => 3}
+ result = scope.function_delete([origin_hash, 'b'])
+ expect(origin_hash).to(eq({'a' => 1, 'b' => 2, 'c' => 3}))
+ end
+
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the delete_undef_values function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("delete_undef_values")).to eq("function_delete_undef_values")
+ end
+
+ it "should raise a ParseError if there is less than 1 argument" do
+ expect { scope.function_delete_undef_values([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a ParseError if the argument is not Array nor Hash" do
+ expect { scope.function_delete_undef_values(['']) }.to( raise_error(Puppet::ParseError))
+ expect { scope.function_delete_undef_values([nil]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should delete all undef items from Array and only these" do
+ result = scope.function_delete_undef_values([['a',:undef,'c','undef']])
+ expect(result).to(eq(['a','c','undef']))
+ end
+
+ it "should delete all undef items from Hash and only these" do
+ result = scope.function_delete_undef_values([{'a'=>'A','b'=>:undef,'c'=>'C','d'=>'undef'}])
+ expect(result).to(eq({'a'=>'A','c'=>'C','d'=>'undef'}))
+ end
+
+ it "should not change origin array passed as argument" do
+ origin_array = ['a',:undef,'c','undef']
+ result = scope.function_delete_undef_values([origin_array])
+ expect(origin_array).to(eq(['a',:undef,'c','undef']))
+ end
+
+ it "should not change origin hash passed as argument" do
+ origin_hash = { 'a' => 1, 'b' => :undef, 'c' => 'undef' }
+ result = scope.function_delete_undef_values([origin_hash])
+ expect(origin_hash).to(eq({ 'a' => 1, 'b' => :undef, 'c' => 'undef' }))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the delete_values function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("delete_values")).to eq("function_delete_values")
+ end
+
+ it "should raise a ParseError if there are fewer than 2 arguments" do
+ expect { scope.function_delete_values([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a ParseError if there are greater than 2 arguments" do
+ expect { scope.function_delete_values([[], 'foo', 'bar']) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a TypeError if the argument is not a hash" do
+ expect { scope.function_delete_values([1,'bar']) }.to( raise_error(TypeError))
+ expect { scope.function_delete_values(['foo','bar']) }.to( raise_error(TypeError))
+ expect { scope.function_delete_values([[],'bar']) }.to( raise_error(TypeError))
+ end
+
+ it "should delete all instances of a value from a hash" do
+ result = scope.function_delete_values([{ 'a'=>'A', 'b'=>'B', 'B'=>'C', 'd'=>'B' },'B'])
+ expect(result).to(eq({ 'a'=>'A', 'B'=>'C' }))
+ end
+
+ it "should not change origin hash passed as argument" do
+ origin_hash = { 'a' => 1, 'b' => 2, 'c' => 3 }
+ result = scope.function_delete_values([origin_hash, 2])
+ expect(origin_hash).to(eq({ 'a' => 1, 'b' => 2, 'c' => 3 }))
+ end
+
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the difference function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("difference")).to eq("function_difference")
+ end
+
+ it "should raise a ParseError if there are fewer than 2 arguments" do
+ expect { scope.function_difference([]) }.to( raise_error(Puppet::ParseError) )
+ end
+
+ it "should return the difference between two arrays" do
+ result = scope.function_difference([["a","b","c"],["b","c","d"]])
+ expect(result).to(eq(["a"]))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the dirname function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("dirname")).to eq("function_dirname")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_dirname([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a ParseError if there is more than 1 argument" do
+ expect { scope.function_dirname(['a', 'b']) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return dirname for an absolute path" do
+ result = scope.function_dirname(['/path/to/a/file.ext'])
+ expect(result).to(eq('/path/to/a'))
+ end
+
+ it "should return dirname for a relative path" do
+ result = scope.function_dirname(['path/to/a/file.ext'])
+ expect(result).to(eq('path/to/a'))
+ end
+
+ it "should complain about hash argument" do
+ expect { scope.function_dirname([{}]) }.to( raise_error(Puppet::ParseError))
+ end
+ it "should complain about list argument" do
+ expect { scope.function_dirname([[]]) }.to( raise_error(Puppet::ParseError))
+ end
+ it "should complain about numeric argument" do
+ expect { scope.function_dirname([2112]) }.to( raise_error(Puppet::ParseError))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the downcase function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("downcase")).to eq("function_downcase")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_downcase([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should downcase a string" do
+ result = scope.function_downcase(["ASFD"])
+ expect(result).to(eq("asfd"))
+ end
+
+ it "should do nothing to a string that is already downcase" do
+ result = scope.function_downcase(["asdf asdf"])
+ expect(result).to(eq("asdf asdf"))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new("ASFD")
+ result = scope.function_downcase([value])
+ result.should(eq('asfd'))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the empty function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("empty")).to eq("function_empty")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_empty([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return a true for an empty string" do
+ result = scope.function_empty([''])
+ expect(result).to(eq(true))
+ end
+
+ it "should return a false for a non-empty string" do
+ result = scope.function_empty(['asdf'])
+ expect(result).to(eq(false))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new()
+ result = scope.function_empty([value])
+ result.should(eq(true))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'rspec-puppet'
+require 'puppet_spec/compiler'
+
+describe 'ensure_packages' do
+ include PuppetSpec::Compiler
+
+ before :each do
+ Puppet::Parser::Functions.autoloader.loadall
+ Puppet::Parser::Functions.function(:ensure_packages)
+ Puppet::Parser::Functions.function(:ensure_resource)
+ Puppet::Parser::Functions.function(:defined_with_params)
+ Puppet::Parser::Functions.function(:create_resources)
+ end
+
+ let :node do Puppet::Node.new('localhost') end
+ let :compiler do Puppet::Parser::Compiler.new(node) end
+ let :scope do
+ if Puppet.version.to_f >= 3.0
+ Puppet::Parser::Scope.new(compiler)
+ else
+ newscope = Puppet::Parser::Scope.new
+ newscope.compiler = compiler
+ newscope.source = Puppet::Resource::Type.new(:node, :localhost)
+ newscope
+ end
+ end
+
+ describe 'argument handling' do
+ it 'fails with no arguments' do
+ expect {
+ scope.function_ensure_packages([])
+ }.to raise_error(Puppet::ParseError, /0 for 1 or 2/)
+ end
+
+ it 'accepts an array of values' do
+ scope.function_ensure_packages([['foo']])
+ end
+
+ it 'accepts a single package name as a string' do
+ scope.function_ensure_packages(['foo'])
+ end
+ end
+
+ context 'given a catalog with puppet package => absent' do
+ let :catalog do
+ compile_to_catalog(<<-EOS
+ ensure_packages(['facter'])
+ package { puppet: ensure => absent }
+ EOS
+ )
+ end
+
+ it 'has no effect on Package[puppet]' do
+ expect(catalog.resource(:package, 'puppet')['ensure']).to eq('absent')
+ end
+ end
+
+ context 'given a clean catalog' do
+ let :catalog do
+ compile_to_catalog('ensure_packages(["facter"])')
+ end
+
+ it 'declares package resources with ensure => present' do
+ expect(catalog.resource(:package, 'facter')['ensure']).to eq('present')
+ end
+ end
+
+ context 'given a clean catalog and specified defaults' do
+ let :catalog do
+ compile_to_catalog('ensure_packages(["facter"], {"provider" => "gem"})')
+ end
+
+ it 'declares package resources with ensure => present' do
+ expect(catalog.resource(:package, 'facter')['ensure']).to eq('present')
+ expect(catalog.resource(:package, 'facter')['provider']).to eq('gem')
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'rspec-puppet'
+require 'puppet_spec/compiler'
+
+describe 'ensure_resource' do
+ include PuppetSpec::Compiler
+
+ before :all do
+ Puppet::Parser::Functions.autoloader.loadall
+ Puppet::Parser::Functions.function(:ensure_packages)
+ end
+
+ let :node do Puppet::Node.new('localhost') end
+ let :compiler do Puppet::Parser::Compiler.new(node) end
+ let :scope do Puppet::Parser::Scope.new(compiler) end
+
+ describe 'when a type or title is not specified' do
+ it { expect { scope.function_ensure_resource([]) }.to raise_error }
+ it { expect { scope.function_ensure_resource(['type']) }.to raise_error }
+ end
+
+ describe 'when compared against a resource with no attributes' do
+ let :catalog do
+ compile_to_catalog(<<-EOS
+ user { "dan": }
+ ensure_resource('user', 'dan', {})
+ EOS
+ )
+ end
+
+ it 'should contain the the ensured resources' do
+ expect(catalog.resource(:user, 'dan').to_s).to eq('User[dan]')
+ end
+ end
+
+ describe 'works when compared against a resource with non-conflicting attributes' do
+ [
+ "ensure_resource('User', 'dan', {})",
+ "ensure_resource('User', 'dan', '')",
+ "ensure_resource('User', 'dan', {'ensure' => 'present'})",
+ "ensure_resource('User', 'dan', {'ensure' => 'present', 'managehome' => false})"
+ ].each do |ensure_resource|
+ pp = <<-EOS
+ user { "dan": ensure => present, shell => "/bin/csh", managehome => false}
+ #{ensure_resource}
+ EOS
+
+ it { expect { compile_to_catalog(pp) }.to_not raise_error }
+ end
+ end
+
+ describe 'fails when compared against a resource with conflicting attributes' do
+ pp = <<-EOS
+ user { "dan": ensure => present, shell => "/bin/csh", managehome => false}
+ ensure_resource('User', 'dan', {'ensure' => 'absent', 'managehome' => false})
+ EOS
+
+ it { expect { compile_to_catalog(pp) }.to raise_error }
+ end
+
+ describe 'when an array of new resources are passed in' do
+ let :catalog do
+ compile_to_catalog("ensure_resource('User', ['dan', 'alex'], {})")
+ end
+
+ it 'should contain the ensured resources' do
+ expect(catalog.resource('User[dan]').to_s).to eq('User[dan]')
+ expect(catalog.resource('User[alex]').to_s).to eq('User[alex]')
+ end
+ end
+
+ describe 'when an array of existing resources is compared against existing resources' do
+ pp = <<-EOS
+ user { 'dan': ensure => present; 'alex': ensure => present }
+ ensure_resource('User', ['dan', 'alex'], {})
+ EOS
+
+ let :catalog do
+ compile_to_catalog(pp)
+ end
+
+ it 'should return the existing resources' do
+ expect(catalog.resource('User[dan]').to_s).to eq('User[dan]')
+ expect(catalog.resource('User[alex]').to_s).to eq('User[alex]')
+ end
+ end
+
+ describe 'works when compared against existing resources with attributes' do
+ [
+ "ensure_resource('User', ['dan', 'alex'], {})",
+ "ensure_resource('User', ['dan', 'alex'], '')",
+ "ensure_resource('User', ['dan', 'alex'], {'ensure' => 'present'})",
+ ].each do |ensure_resource|
+ pp = <<-EOS
+ user { 'dan': ensure => present; 'alex': ensure => present }
+ #{ensure_resource}
+ EOS
+
+ it { expect { compile_to_catalog(pp) }.to_not raise_error }
+ end
+ end
+
+ describe 'fails when compared against existing resources with conflicting attributes' do
+ pp = <<-EOS
+ user { 'dan': ensure => present; 'alex': ensure => present }
+ ensure_resource('User', ['dan', 'alex'], {'ensure' => 'absent'})
+ EOS
+
+ it { expect { compile_to_catalog(pp) }.to raise_error }
+ end
+
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the flatten function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("flatten")).to eq("function_flatten")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_flatten([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a ParseError if there is more than 1 argument" do
+ expect { scope.function_flatten([[], []]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should flatten a complex data structure" do
+ result = scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]])
+ expect(result).to(eq(["a","b","c","d","e","f","g"]))
+ end
+
+ it "should do nothing to a structure that is already flat" do
+ result = scope.function_flatten([["a","b","c","d"]])
+ expect(result).to(eq(["a","b","c","d"]))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the floor function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("floor")).to eq("function_floor")
+ end
+
+ it "should raise a ParseError if there is less than 1 argument" do
+ expect { scope.function_floor([]) }.to( raise_error(Puppet::ParseError, /Wrong number of arguments/))
+ end
+
+ it "should should raise a ParseError if input isn't numeric (eg. String)" do
+ expect { scope.function_floor(["foo"]) }.to( raise_error(Puppet::ParseError, /Wrong argument type/))
+ end
+
+ it "should should raise a ParseError if input isn't numeric (eg. Boolean)" do
+ expect { scope.function_floor([true]) }.to( raise_error(Puppet::ParseError, /Wrong argument type/))
+ end
+
+ it "should return an integer when a numeric type is passed" do
+ result = scope.function_floor([12.4])
+ expect(result.is_a?(Integer)).to(eq(true))
+ end
+
+ it "should return the input when an integer is passed" do
+ result = scope.function_floor([7])
+ expect(result).to(eq(7))
+ end
+
+ it "should return the largest integer less than or equal to the input" do
+ result = scope.function_floor([3.8])
+ expect(result).to(eq(3))
+ end
+end
+
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the fqdn_rand_string function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("fqdn_rand_string")).to eq("function_fqdn_rand_string")
+ end
+
+ it "should raise an ArgumentError if there is less than 1 argument" do
+ expect { fqdn_rand_string() }.to( raise_error(ArgumentError, /wrong number of arguments/))
+ end
+
+ it "should raise an ArgumentError if argument 1 isn't a positive integer" do
+ expect { fqdn_rand_string(0) }.to( raise_error(ArgumentError, /first argument must be a positive integer/))
+ expect { fqdn_rand_string(-1) }.to( raise_error(ArgumentError, /first argument must be a positive integer/))
+ expect { fqdn_rand_string(0.5) }.to( raise_error(ArgumentError, /first argument must be a positive integer/))
+ end
+
+ it "provides a valid alphanumeric string when no character set is provided" do
+ length = 100
+ string = %r{\A[a-zA-Z0-9]{#{length}}\z}
+ expect(fqdn_rand_string(length).match(string)).not_to eq(nil)
+ end
+
+ it "provides a valid alphanumeric string when an undef character set is provided" do
+ length = 100
+ string = %r{\A[a-zA-Z0-9]{#{length}}\z}
+ expect(fqdn_rand_string(length, :charset => nil).match(string)).not_to eq(nil)
+ end
+
+ it "provides a valid alphanumeric string when an empty character set is provided" do
+ length = 100
+ string = %r{\A[a-zA-Z0-9]{#{length}}\z}
+ expect(fqdn_rand_string(length, :charset => '').match(string)).not_to eq(nil)
+ end
+
+ it "uses a provided character set" do
+ length = 100
+ charset = '!@#$%^&*()-_=+'
+ string = %r{\A[#{charset}]{#{length}}\z}
+ expect(fqdn_rand_string(length, :charset => charset).match(string)).not_to eq(nil)
+ end
+
+ it "provides a random string exactly as long as the given length" do
+ expect(fqdn_rand_string(10).size).to eql(10)
+ end
+
+ it "provides the same 'random' value on subsequent calls for the same host" do
+ expect(fqdn_rand_string(10)).to eql(fqdn_rand_string(10))
+ end
+
+ it "considers the same host and same extra arguments to have the same random sequence" do
+ first_random = fqdn_rand_string(10, :extra_identifier => [1, "same", "host"])
+ second_random = fqdn_rand_string(10, :extra_identifier => [1, "same", "host"])
+
+ expect(first_random).to eql(second_random)
+ end
+
+ it "allows extra arguments to control the random value on a single host" do
+ first_random = fqdn_rand_string(10, :extra_identifier => [1, "different", "host"])
+ second_different_random = fqdn_rand_string(10, :extra_identifier => [2, "different", "host"])
+
+ expect(first_random).not_to eql(second_different_random)
+ end
+
+ it "should return different strings for different hosts" do
+ val1 = fqdn_rand_string(10, :host => "first.host.com")
+ val2 = fqdn_rand_string(10, :host => "second.host.com")
+
+ expect(val1).not_to eql(val2)
+ end
+
+ def fqdn_rand_string(max, args = {})
+ host = args[:host] || '127.0.0.1'
+ charset = args[:charset]
+ extra = args[:extra_identifier] || []
+
+ scope = PuppetlabsSpec::PuppetInternals.scope
+ scope.stubs(:[]).with("::fqdn").returns(host)
+ scope.stubs(:lookupvar).with("::fqdn").returns(host)
+
+ function_args = [max]
+ if args.has_key?(:charset) or !extra.empty?
+ function_args << charset
+ end
+ function_args += extra
+ scope.function_fqdn_rand_string(function_args)
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the fqdn_rotate function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("fqdn_rotate")).to eq("function_fqdn_rotate")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_fqdn_rotate([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should rotate a string and the result should be the same size" do
+ scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
+ result = scope.function_fqdn_rotate(["asdf"])
+ expect(result.size).to(eq(4))
+ end
+
+ it "should rotate a string to give the same results for one host" do
+ scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1").twice
+ expect(scope.function_fqdn_rotate(["abcdefg"])).to eql(scope.function_fqdn_rotate(["abcdefg"]))
+ end
+
+ it "should rotate a string to give different values on different hosts" do
+ scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
+ val1 = scope.function_fqdn_rotate(["abcdefghijklmnopqrstuvwxyz01234567890987654321"])
+ scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.2")
+ val2 = scope.function_fqdn_rotate(["abcdefghijklmnopqrstuvwxyz01234567890987654321"])
+ expect(val1).not_to eql(val2)
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
+ value = AlsoString.new("asdf")
+ result = scope.function_fqdn_rotate([value])
+ result.size.should(eq(4))
+ end
+
+ it "should use the Puppet::Util.deterministic_rand function if available" do
+ scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
+ if Puppet::Util.respond_to?(:deterministic_rand)
+ Puppet::Util.expects(:deterministic_rand).with(113646079810780526294648115052177588845,4)
+ end
+ scope.function_fqdn_rotate(["asdf"])
+ end
+
+ it "should not leave the global seed in a deterministic state" do
+ scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1").twice
+ scope.function_fqdn_rotate(["asdf"])
+ rand1 = rand()
+ scope.function_fqdn_rotate(["asdf"])
+ rand2 = rand()
+ expect(rand1).not_to eql(rand2)
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:get_module_path) do
+ Internals = PuppetlabsSpec::PuppetInternals
+ class StubModule
+ attr_reader :path
+ def initialize(path)
+ @path = path
+ end
+ end
+
+ def scope(environment = "production")
+ Internals.scope(:compiler => Internals.compiler(:node => Internals.node(:environment => environment)))
+ end
+
+ it 'should only allow one argument' do
+ expect { scope.function_get_module_path([]) }.to raise_error(Puppet::ParseError, /Wrong number of arguments, expects one/)
+ expect { scope.function_get_module_path(['1','2','3']) }.to raise_error(Puppet::ParseError, /Wrong number of arguments, expects one/)
+ end
+ it 'should raise an exception when the module cannot be found' do
+ expect { scope.function_get_module_path(['foo']) }.to raise_error(Puppet::ParseError, /Could not find module/)
+ end
+ describe 'when locating a module' do
+ let(:modulepath) { "/tmp/does_not_exist" }
+ let(:path_of_module_foo) { StubModule.new("/tmp/does_not_exist/foo") }
+
+ before(:each) { Puppet[:modulepath] = modulepath }
+
+ it 'should be able to find module paths from the modulepath setting' do
+ Puppet::Module.expects(:find).with('foo', 'production').returns(path_of_module_foo)
+ expect(scope.function_get_module_path(['foo'])).to eq(path_of_module_foo.path)
+ end
+ it 'should be able to find module paths when the modulepath is a list' do
+ Puppet[:modulepath] = modulepath + ":/tmp"
+ Puppet::Module.expects(:find).with('foo', 'production').returns(path_of_module_foo)
+ expect(scope.function_get_module_path(['foo'])).to eq(path_of_module_foo.path)
+ end
+ it 'should respect the environment' do
+ skip("Disabled on Puppet 2.6.x") if Puppet.version =~ /^2\.6\b/
+ Puppet.settings[:environment] = 'danstestenv'
+ Puppet::Module.expects(:find).with('foo', 'danstestenv').returns(path_of_module_foo)
+ expect(scope('danstestenv').function_get_module_path(['foo'])).to eq(path_of_module_foo.path)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'rspec-puppet'
+require 'puppet_spec/compiler'
+
+describe 'getparam' do
+ include PuppetSpec::Compiler
+
+ before :each do
+ Puppet::Parser::Functions.autoloader.loadall
+ Puppet::Parser::Functions.function(:getparam)
+ end
+
+ let :node do Puppet::Node.new('localhost') end
+ let :compiler do Puppet::Parser::Compiler.new(node) end
+ if Puppet.version.to_f >= 3.0
+ let :scope do Puppet::Parser::Scope.new(compiler) end
+ else
+ let :scope do
+ newscope = Puppet::Parser::Scope.new
+ newscope.compiler = compiler
+ newscope.source = Puppet::Resource::Type.new(:node, :localhost)
+ newscope
+ end
+ end
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("getparam")).to eq("function_getparam")
+ end
+
+ describe 'when a resource is not specified' do
+ it { expect { scope.function_getparam([]) }.to raise_error }
+ it { expect { scope.function_getparam(['User[dan]']) }.to raise_error }
+ it { expect { scope.function_getparam(['User[dan]']) }.to raise_error }
+ it { expect { scope.function_getparam(['User[dan]', {}]) }.to raise_error }
+ # This seems to be OK because we just check for a string.
+ it { expect { scope.function_getparam(['User[dan]', '']) }.to_not raise_error }
+ end
+
+ describe 'when compared against a resource with no params' do
+ let :catalog do
+ compile_to_catalog(<<-EOS
+ user { "dan": }
+ EOS
+ )
+ end
+
+ it do
+ expect(scope.function_getparam(['User[dan]', 'shell'])).to eq('')
+ end
+ end
+
+ describe 'when compared against a resource with params' do
+ let :catalog do
+ compile_to_catalog(<<-EOS
+ user { 'dan': ensure => present, shell => '/bin/sh', managehome => false}
+ $test = getparam(User[dan], 'shell')
+ EOS
+ )
+ end
+
+ it do
+ resource = Puppet::Parser::Resource.new(:user, 'dan', {:scope => scope})
+ resource.set_parameter('ensure', 'present')
+ resource.set_parameter('shell', '/bin/sh')
+ resource.set_parameter('managehome', false)
+ compiler.add_resource(scope, resource)
+
+ expect(scope.function_getparam(['User[dan]', 'shell'])).to eq('/bin/sh')
+ expect(scope.function_getparam(['User[dan]', ''])).to eq('')
+ expect(scope.function_getparam(['User[dan]', 'ensure'])).to eq('present')
+ # TODO: Expected this to be false, figure out why we're getting '' back.
+ expect(scope.function_getparam(['User[dan]', 'managehome'])).to eq('')
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:getvar) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+ describe 'when calling getvar from puppet' do
+
+ it "should not compile when no arguments are passed" do
+ skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+ Puppet[:code] = '$foo = getvar()'
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+ end
+
+ it "should not compile when too many arguments are passed" do
+ skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+ Puppet[:code] = '$foo = getvar("foo::bar", "baz")'
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+ end
+
+ it "should lookup variables in other namespaces" do
+ skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ class site::data { $foo = 'baz' }
+ include site::data
+ $foo = getvar("site::data::foo")
+ if $foo != 'baz' {
+ fail('getvar did not return what we expect')
+ }
+ ENDofPUPPETcode
+ scope.compiler.compile
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the grep function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("grep")).to eq("function_grep")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_grep([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should grep contents from an array" do
+ result = scope.function_grep([["aaabbb","bbbccc","dddeee"], "bbb"])
+ expect(result).to(eq(["aaabbb","bbbccc"]))
+ end
+end
--- /dev/null
+#!/usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:has_interface_with) do
+
+ let(:scope) do
+ PuppetlabsSpec::PuppetInternals.scope
+ end
+
+ # The subject of these examples is the method itself.
+ subject do
+ function_name = Puppet::Parser::Functions.function(:has_interface_with)
+ scope.method(function_name)
+ end
+
+ # We need to mock out the Facts so we can specify how we expect this function
+ # to behave on different platforms.
+ context "On Mac OS X Systems" do
+ before :each do
+ scope.stubs(:lookupvar).with("interfaces").returns('lo0,gif0,stf0,en1,p2p0,fw0,en0,vmnet1,vmnet8,utun0')
+ end
+ it 'should have loopback (lo0)' do
+ expect(subject.call(['lo0'])).to be_truthy
+ end
+ it 'should not have loopback (lo)' do
+ expect(subject.call(['lo'])).to be_falsey
+ end
+ end
+ context "On Linux Systems" do
+ before :each do
+ scope.stubs(:lookupvar).with("interfaces").returns('eth0,lo')
+ scope.stubs(:lookupvar).with("ipaddress").returns('10.0.0.1')
+ scope.stubs(:lookupvar).with("ipaddress_lo").returns('127.0.0.1')
+ scope.stubs(:lookupvar).with("ipaddress_eth0").returns('10.0.0.1')
+ scope.stubs(:lookupvar).with('muppet').returns('kermit')
+ scope.stubs(:lookupvar).with('muppet_lo').returns('mspiggy')
+ scope.stubs(:lookupvar).with('muppet_eth0').returns('kermit')
+ end
+ it 'should have loopback (lo)' do
+ expect(subject.call(['lo'])).to be_truthy
+ end
+ it 'should not have loopback (lo0)' do
+ expect(subject.call(['lo0'])).to be_falsey
+ end
+ it 'should have ipaddress with 127.0.0.1' do
+ expect(subject.call(['ipaddress', '127.0.0.1'])).to be_truthy
+ end
+ it 'should have ipaddress with 10.0.0.1' do
+ expect(subject.call(['ipaddress', '10.0.0.1'])).to be_truthy
+ end
+ it 'should not have ipaddress with 10.0.0.2' do
+ expect(subject.call(['ipaddress', '10.0.0.2'])).to be_falsey
+ end
+ it 'should have muppet named kermit' do
+ expect(subject.call(['muppet', 'kermit'])).to be_truthy
+ end
+ it 'should have muppet named mspiggy' do
+ expect(subject.call(['muppet', 'mspiggy'])).to be_truthy
+ end
+ it 'should not have muppet named bigbird' do
+ expect(subject.call(['muppet', 'bigbird'])).to be_falsey
+ end
+ end
+end
--- /dev/null
+#!/usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:has_ip_address) do
+
+ let(:scope) do
+ PuppetlabsSpec::PuppetInternals.scope
+ end
+
+ subject do
+ function_name = Puppet::Parser::Functions.function(:has_ip_address)
+ scope.method(function_name)
+ end
+
+ context "On Linux Systems" do
+ before :each do
+ scope.stubs(:lookupvar).with('interfaces').returns('eth0,lo')
+ scope.stubs(:lookupvar).with('ipaddress').returns('10.0.2.15')
+ scope.stubs(:lookupvar).with('ipaddress_eth0').returns('10.0.2.15')
+ scope.stubs(:lookupvar).with('ipaddress_lo').returns('127.0.0.1')
+ end
+
+ it 'should have primary address (10.0.2.15)' do
+ expect(subject.call(['10.0.2.15'])).to be_truthy
+ end
+
+ it 'should have lookupback address (127.0.0.1)' do
+ expect(subject.call(['127.0.0.1'])).to be_truthy
+ end
+
+ it 'should not have other address' do
+ expect(subject.call(['192.1681.1.1'])).to be_falsey
+ end
+
+ it 'should not have "mspiggy" on an interface' do
+ expect(subject.call(['mspiggy'])).to be_falsey
+ end
+ end
+end
--- /dev/null
+#!/usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:has_ip_network) do
+
+ let(:scope) do
+ PuppetlabsSpec::PuppetInternals.scope
+ end
+
+ subject do
+ function_name = Puppet::Parser::Functions.function(:has_ip_network)
+ scope.method(function_name)
+ end
+
+ context "On Linux Systems" do
+ before :each do
+ scope.stubs(:lookupvar).with('interfaces').returns('eth0,lo')
+ scope.stubs(:lookupvar).with('network').returns(:undefined)
+ scope.stubs(:lookupvar).with('network_eth0').returns('10.0.2.0')
+ scope.stubs(:lookupvar).with('network_lo').returns('127.0.0.1')
+ end
+
+ it 'should have primary network (10.0.2.0)' do
+ expect(subject.call(['10.0.2.0'])).to be_truthy
+ end
+
+ it 'should have loopback network (127.0.0.0)' do
+ expect(subject.call(['127.0.0.1'])).to be_truthy
+ end
+
+ it 'should not have other network' do
+ expect(subject.call(['192.168.1.0'])).to be_falsey
+ end
+ end
+end
+
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:has_key) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ describe 'when calling has_key from puppet' do
+ it "should not compile when no arguments are passed" do
+ skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+ Puppet[:code] = '$x = has_key()'
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+ end
+
+ it "should not compile when 1 argument is passed" do
+ skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+ Puppet[:code] = "$x = has_key('foo')"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+ end
+
+ it "should require the first value to be a Hash" do
+ skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+ Puppet[:code] = "$x = has_key('foo', 'bar')"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /expects the first argument to be a hash/)
+ end
+ end
+
+ describe 'when calling the function has_key from a scope instance' do
+ it 'should detect existing keys' do
+ expect(scope.function_has_key([{'one' => 1}, 'one'])).to be_truthy
+ end
+
+ it 'should detect existing keys' do
+ expect(scope.function_has_key([{'one' => 1}, 'two'])).to be_falsey
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the hash function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("hash")).to eq("function_hash")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_hash([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should convert an array to a hash" do
+ result = scope.function_hash([['a',1,'b',2,'c',3]])
+ expect(result).to(eq({'a'=>1,'b'=>2,'c'=>3}))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the intersection function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("intersection")).to eq("function_intersection")
+ end
+
+ it "should raise a ParseError if there are fewer than 2 arguments" do
+ expect { scope.function_intersection([]) }.to( raise_error(Puppet::ParseError) )
+ end
+
+ it "should return the intersection of two arrays" do
+ result = scope.function_intersection([["a","b","c"],["b","c","d"]])
+ expect(result).to(eq(["b","c"]))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_array function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("is_array")).to eq("function_is_array")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_is_array([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if passed an array" do
+ result = scope.function_is_array([[1,2,3]])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if passed a hash" do
+ result = scope.function_is_array([{'a'=>1}])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if passed a string" do
+ result = scope.function_is_array(["asdf"])
+ expect(result).to(eq(false))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_bool function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("is_bool")).to eq("function_is_bool")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_is_bool([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if passed a TrueClass" do
+ result = scope.function_is_bool([true])
+ expect(result).to(eq(true))
+ end
+
+ it "should return true if passed a FalseClass" do
+ result = scope.function_is_bool([false])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if passed the string 'true'" do
+ result = scope.function_is_bool(['true'])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if passed the string 'false'" do
+ result = scope.function_is_bool(['false'])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if passed an array" do
+ result = scope.function_is_bool([["a","b"]])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if passed a hash" do
+ result = scope.function_is_bool([{"a" => "b"}])
+ expect(result).to(eq(false))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_domain_name function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("is_domain_name")).to eq("function_is_domain_name")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_is_domain_name([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if a valid short domain name" do
+ result = scope.function_is_domain_name(["x.com"])
+ expect(result).to(be_truthy)
+ end
+
+ it "should return true if the domain is ." do
+ result = scope.function_is_domain_name(["."])
+ expect(result).to(be_truthy)
+ end
+
+ it "should return true if the domain is x.com." do
+ result = scope.function_is_domain_name(["x.com."])
+ expect(result).to(be_truthy)
+ end
+
+ it "should return true if a valid domain name" do
+ result = scope.function_is_domain_name(["foo.bar.com"])
+ expect(result).to(be_truthy)
+ end
+
+ it "should allow domain parts to start with numbers" do
+ result = scope.function_is_domain_name(["3foo.2bar.com"])
+ expect(result).to(be_truthy)
+ end
+
+ it "should allow domain to end with a dot" do
+ result = scope.function_is_domain_name(["3foo.2bar.com."])
+ expect(result).to(be_truthy)
+ end
+
+ it "should allow a single part domain" do
+ result = scope.function_is_domain_name(["orange"])
+ expect(result).to(be_truthy)
+ end
+
+ it "should return false if domain parts start with hyphens" do
+ result = scope.function_is_domain_name(["-3foo.2bar.com"])
+ expect(result).to(be_falsey)
+ end
+
+ it "should return true if domain contains hyphens" do
+ result = scope.function_is_domain_name(["3foo-bar.2bar-fuzz.com"])
+ expect(result).to(be_truthy)
+ end
+
+ it "should return false if domain name contains spaces" do
+ result = scope.function_is_domain_name(["not valid"])
+ expect(result).to(be_falsey)
+ end
+
+ # Values obtained from Facter values will be frozen strings
+ # in newer versions of Facter:
+ it "should not throw an exception if passed a frozen string" do
+ result = scope.function_is_domain_name(["my.domain.name".freeze])
+ expect(result).to(be_truthy)
+ end
+
+ it "should return false if top-level domain is not entirely alphabetic" do
+ result = scope.function_is_domain_name(["kiwi.2bar"])
+ expect(result).to(be_falsey)
+ end
+
+ it "should return false if domain name has the dotted-decimal form, e.g. an IPv4 address" do
+ result = scope.function_is_domain_name(["192.168.1.1"])
+ expect(result).to(be_falsey)
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_float function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("is_float")).to eq("function_is_float")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_is_float([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if a float" do
+ result = scope.function_is_float(["0.12"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if a string" do
+ result = scope.function_is_float(["asdf"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if an integer" do
+ result = scope.function_is_float(["3"])
+ expect(result).to(eq(false))
+ end
+ it "should return true if a float is created from an arithmetical operation" do
+ result = scope.function_is_float([3.2*2])
+ expect(result).to(eq(true))
+ end
+end
--- /dev/null
+#!/usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_function_available function" do
+ before :all do
+ Puppet::Parser::Functions.autoloader.loadall
+ end
+
+ before :each do
+ @scope = Puppet::Parser::Scope.new
+ end
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("is_function_available")).to eq("function_is_function_available")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { @scope.function_is_function_available([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return false if a nonexistent function is passed" do
+ result = @scope.function_is_function_available(['jeff_mccunes_left_sock'])
+ expect(result).to(eq(false))
+ end
+
+ it "should return true if an available function is passed" do
+ result = @scope.function_is_function_available(['require'])
+ expect(result).to(eq(true))
+ end
+
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_hash function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("is_hash")).to eq("function_is_hash")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_is_hash([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if passed a hash" do
+ result = scope.function_is_hash([{"a"=>1,"b"=>2}])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if passed an array" do
+ result = scope.function_is_hash([["a","b"]])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if passed a string" do
+ result = scope.function_is_hash(["asdf"])
+ expect(result).to(eq(false))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_integer function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("is_integer")).to eq("function_is_integer")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_is_integer([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if an integer" do
+ result = scope.function_is_integer(["3"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return true if a negative integer" do
+ result = scope.function_is_integer(["-7"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if a float" do
+ result = scope.function_is_integer(["3.2"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if a string" do
+ result = scope.function_is_integer(["asdf"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return true if an integer is created from an arithmetical operation" do
+ result = scope.function_is_integer([3*2])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if an array" do
+ result = scope.function_is_numeric([["asdf"]])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if a hash" do
+ result = scope.function_is_numeric([{"asdf" => false}])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if a boolean" do
+ result = scope.function_is_numeric([true])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if a whitespace is in the string" do
+ result = scope.function_is_numeric([" -1324"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if it is zero prefixed" do
+ result = scope.function_is_numeric(["0001234"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if it is wrapped inside an array" do
+ result = scope.function_is_numeric([[1234]])
+ expect(result).to(eq(false))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_ip_address function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("is_ip_address")).to eq("function_is_ip_address")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_is_ip_address([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if an IPv4 address" do
+ result = scope.function_is_ip_address(["1.2.3.4"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return true if a full IPv6 address" do
+ result = scope.function_is_ip_address(["fe80:0000:cd12:d123:e2f8:47ff:fe09:dd74"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return true if a compressed IPv6 address" do
+ result = scope.function_is_ip_address(["fe00::1"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if not valid" do
+ result = scope.function_is_ip_address(["asdf"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if IP octets out of range" do
+ result = scope.function_is_ip_address(["1.1.1.300"])
+ expect(result).to(eq(false))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_mac_address function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("is_mac_address")).to eq("function_is_mac_address")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_is_mac_address([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if a valid mac address" do
+ result = scope.function_is_mac_address(["00:a0:1f:12:7f:a0"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if octets are out of range" do
+ result = scope.function_is_mac_address(["00:a0:1f:12:7f:g0"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if not valid" do
+ result = scope.function_is_mac_address(["not valid"])
+ expect(result).to(eq(false))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_numeric function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("is_numeric")).to eq("function_is_numeric")
+ end
+
+ it "should raise a ParseError if there is less than 1 argument" do
+ expect { scope.function_is_numeric([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if an integer" do
+ result = scope.function_is_numeric(["3"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return true if a float" do
+ result = scope.function_is_numeric(["3.2"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return true if an integer is created from an arithmetical operation" do
+ result = scope.function_is_numeric([3*2])
+ expect(result).to(eq(true))
+ end
+
+ it "should return true if a float is created from an arithmetical operation" do
+ result = scope.function_is_numeric([3.2*2])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if a string" do
+ result = scope.function_is_numeric(["asdf"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if an array" do
+ result = scope.function_is_numeric([["asdf"]])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if an array of integers" do
+ result = scope.function_is_numeric([[1,2,3,4]])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if a hash" do
+ result = scope.function_is_numeric([{"asdf" => false}])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if a hash with numbers in it" do
+ result = scope.function_is_numeric([{1 => 2}])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if a boolean" do
+ result = scope.function_is_numeric([true])
+ expect(result).to(eq(false))
+ end
+
+ it "should return true if a negative float with exponent" do
+ result = scope.function_is_numeric(["-342.2315e-12"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if a negative integer with whitespaces before/after the dash" do
+ result = scope.function_is_numeric([" - 751"])
+ expect(result).to(eq(false))
+ end
+
+# it "should return true if a hexadecimal" do
+# result = scope.function_is_numeric(["0x52F8c"])
+# result.should(eq(true))
+# end
+#
+# it "should return true if a hexadecimal with uppercase 0X prefix" do
+# result = scope.function_is_numeric(["0X52F8c"])
+# result.should(eq(true))
+# end
+#
+# it "should return false if a hexadecimal without a prefix" do
+# result = scope.function_is_numeric(["52F8c"])
+# result.should(eq(false))
+# end
+#
+# it "should return true if a octal" do
+# result = scope.function_is_numeric(["0751"])
+# result.should(eq(true))
+# end
+#
+# it "should return true if a negative hexadecimal" do
+# result = scope.function_is_numeric(["-0x52F8c"])
+# result.should(eq(true))
+# end
+#
+# it "should return true if a negative octal" do
+# result = scope.function_is_numeric(["-0751"])
+# result.should(eq(true))
+# end
+#
+# it "should return false if a negative octal with whitespaces before/after the dash" do
+# result = scope.function_is_numeric([" - 0751"])
+# result.should(eq(false))
+# end
+#
+# it "should return false if a bad hexadecimal" do
+# result = scope.function_is_numeric(["0x23d7g"])
+# result.should(eq(false))
+# end
+#
+# it "should return false if a bad octal" do
+# result = scope.function_is_numeric(["0287"])
+# result.should(eq(false))
+# end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the is_string function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("is_string")).to eq("function_is_string")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_is_string([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if a string" do
+ result = scope.function_is_string(["asdf"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if an integer" do
+ result = scope.function_is_string(["3"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if a float" do
+ result = scope.function_is_string(["3.23"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return false if an array" do
+ result = scope.function_is_string([["a","b","c"]])
+ expect(result).to(eq(false))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the join_keys_to_values function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("join_keys_to_values")).to eq("function_join_keys_to_values")
+ end
+
+ it "should raise a ParseError if there are fewer than two arguments" do
+ expect { scope.function_join_keys_to_values([{}]) }.to raise_error Puppet::ParseError
+ end
+
+ it "should raise a ParseError if there are greater than two arguments" do
+ expect { scope.function_join_keys_to_values([{}, 'foo', 'bar']) }.to raise_error Puppet::ParseError
+ end
+
+ it "should raise a TypeError if the first argument is an array" do
+ expect { scope.function_join_keys_to_values([[1,2], ',']) }.to raise_error TypeError
+ end
+
+ it "should raise a TypeError if the second argument is an array" do
+ expect { scope.function_join_keys_to_values([{}, [1,2]]) }.to raise_error TypeError
+ end
+
+ it "should raise a TypeError if the second argument is a number" do
+ expect { scope.function_join_keys_to_values([{}, 1]) }.to raise_error TypeError
+ end
+
+ it "should return an empty array given an empty hash" do
+ result = scope.function_join_keys_to_values([{}, ":"])
+ expect(result).to eq([])
+ end
+
+ it "should join hash's keys to its values" do
+ result = scope.function_join_keys_to_values([{'a'=>1,2=>'foo',:b=>nil}, ":"])
+ expect(result).to match_array(['a:1','2:foo','b:'])
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the join function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("join")).to eq("function_join")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_join([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should join an array into a string" do
+ result = scope.function_join([["a","b","c"], ":"])
+ expect(result).to(eq("a:b:c"))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the keys function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("keys")).to eq("function_keys")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_keys([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return an array of keys when given a hash" do
+ result = scope.function_keys([{'a'=>1, 'b'=>2}])
+ # =~ performs 'array with same elements' (set) matching
+ # For more info see RSpec::Matchers::MatchArray
+ expect(result).to match_array(['a','b'])
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the loadyaml function" do
+ include PuppetlabsSpec::Files
+
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("loadyaml")).to eq("function_loadyaml")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_loadyaml([]) }.to raise_error(Puppet::ParseError)
+ end
+
+ it "should convert YAML file to a data structure" do
+ yaml_file = tmpfilename ('yamlfile')
+ File.open(yaml_file, 'w') do |fh|
+ fh.write("---\n aaa: 1\n bbb: 2\n ccc: 3\n ddd: 4\n")
+ end
+ result = scope.function_loadyaml([yaml_file])
+ expect(result).to eq({"aaa" => 1, "bbb" => 2, "ccc" => 3, "ddd" => 4 })
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the lstrip function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("lstrip")).to eq("function_lstrip")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_lstrip([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should lstrip a string" do
+ result = scope.function_lstrip([" asdf"])
+ expect(result).to(eq('asdf'))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new(" asdf")
+ result = scope.function_lstrip([value])
+ result.should(eq("asdf"))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the max function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("max")).to eq("function_max")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_max([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should be able to compare strings" do
+ expect(scope.function_max(["albatross","dog","horse"])).to(eq("horse"))
+ end
+
+ it "should be able to compare numbers" do
+ expect(scope.function_max([6,8,4])).to(eq(8))
+ end
+
+ it "should be able to compare a number with a stringified number" do
+ expect(scope.function_max([1,"2"])).to(eq("2"))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the member function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("member")).to eq("function_member")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_member([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if a member is in an array" do
+ result = scope.function_member([["a","b","c"], "a"])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if a member is not in an array" do
+ result = scope.function_member([["a","b","c"], "d"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return true if a member array is in an array" do
+ result = scope.function_member([["a","b","c"], ["a", "b"]])
+ expect(result).to(eq(true))
+ end
+
+ it "should return false if a member array is not in an array" do
+ result = scope.function_member([["a","b","c"], ["d", "e"]])
+ expect(result).to(eq(false))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:merge) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ describe 'when calling merge from puppet' do
+ it "should not compile when no arguments are passed" do
+ skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+ Puppet[:code] = '$x = merge()'
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+ end
+
+ it "should not compile when 1 argument is passed" do
+ skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
+ Puppet[:code] = "$my_hash={'one' => 1}\n$x = merge($my_hash)"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+ end
+ end
+
+ describe 'when calling merge on the scope instance' do
+ it 'should require all parameters are hashes' do
+ expect { new_hash = scope.function_merge([{}, '2'])}.to raise_error(Puppet::ParseError, /unexpected argument type String/)
+ expect { new_hash = scope.function_merge([{}, 2])}.to raise_error(Puppet::ParseError, /unexpected argument type Fixnum/)
+ end
+
+ it 'should accept empty strings as puppet undef' do
+ expect { new_hash = scope.function_merge([{}, ''])}.not_to raise_error
+ end
+
+ it 'should be able to merge two hashes' do
+ new_hash = scope.function_merge([{'one' => '1', 'two' => '1'}, {'two' => '2', 'three' => '2'}])
+ expect(new_hash['one']).to eq('1')
+ expect(new_hash['two']).to eq('2')
+ expect(new_hash['three']).to eq('2')
+ end
+
+ it 'should merge multiple hashes' do
+ hash = scope.function_merge([{'one' => 1}, {'one' => '2'}, {'one' => '3'}])
+ expect(hash['one']).to eq('3')
+ end
+
+ it 'should accept empty hashes' do
+ expect(scope.function_merge([{},{},{}])).to eq({})
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the min function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("min")).to eq("function_min")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_min([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should be able to compare strings" do
+ expect(scope.function_min(["albatross","dog","horse"])).to(eq("albatross"))
+ end
+
+ it "should be able to compare numbers" do
+ expect(scope.function_min([6,8,4])).to(eq(4))
+ end
+
+ it "should be able to compare a number with a stringified number" do
+ expect(scope.function_min([1,"2"])).to(eq(1))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the num2bool function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("num2bool")).to eq("function_num2bool")
+ end
+
+ it "should raise a ParseError if there are no arguments" do
+ expect { scope.function_num2bool([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a ParseError if there are more than 1 arguments" do
+ expect { scope.function_num2bool(["foo","bar"]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a ParseError if passed something non-numeric" do
+ expect { scope.function_num2bool(["xyzzy"]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return true if passed string 1" do
+ result = scope.function_num2bool(["1"])
+ expect(result).to(be_truthy)
+ end
+
+ it "should return true if passed string 1.5" do
+ result = scope.function_num2bool(["1.5"])
+ expect(result).to(be_truthy)
+ end
+
+ it "should return true if passed number 1" do
+ result = scope.function_num2bool([1])
+ expect(result).to(be_truthy)
+ end
+
+ it "should return false if passed string 0" do
+ result = scope.function_num2bool(["0"])
+ expect(result).to(be_falsey)
+ end
+
+ it "should return false if passed number 0" do
+ result = scope.function_num2bool([0])
+ expect(result).to(be_falsey)
+ end
+
+ it "should return false if passed string -1" do
+ result = scope.function_num2bool(["-1"])
+ expect(result).to(be_falsey)
+ end
+
+ it "should return false if passed string -1.5" do
+ result = scope.function_num2bool(["-1.5"])
+ expect(result).to(be_falsey)
+ end
+
+ it "should return false if passed number -1" do
+ result = scope.function_num2bool([-1])
+ expect(result).to(be_falsey)
+ end
+
+ it "should return false if passed float -1.5" do
+ result = scope.function_num2bool([-1.5])
+ expect(result).to(be_falsey)
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the parsejson function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("parsejson")).to eq("function_parsejson")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_parsejson([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should convert JSON to a data structure" do
+ json = <<-EOS
+["aaa","bbb","ccc"]
+EOS
+ result = scope.function_parsejson([json])
+ expect(result).to(eq(['aaa','bbb','ccc']))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the parseyaml function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("parseyaml")).to eq("function_parseyaml")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_parseyaml([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should convert YAML to a data structure" do
+ yaml = <<-EOS
+- aaa
+- bbb
+- ccc
+EOS
+ result = scope.function_parseyaml([yaml])
+ expect(result).to(eq(['aaa','bbb','ccc']))
+ end
+end
--- /dev/null
+#!/usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the pick_default function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("pick_default")).to eq("function_pick_default")
+ end
+
+ it 'should return the correct value' do
+ expect(scope.function_pick_default(['first', 'second'])).to eq('first')
+ end
+
+ it 'should return the correct value if the first value is empty' do
+ expect(scope.function_pick_default(['', 'second'])).to eq('second')
+ end
+
+ it 'should skip empty string values' do
+ expect(scope.function_pick_default(['', 'first'])).to eq('first')
+ end
+
+ it 'should skip :undef values' do
+ expect(scope.function_pick_default([:undef, 'first'])).to eq('first')
+ end
+
+ it 'should skip :undefined values' do
+ expect(scope.function_pick_default([:undefined, 'first'])).to eq('first')
+ end
+
+ it 'should return the empty string if it is the last possibility' do
+ expect(scope.function_pick_default([:undef, :undefined, ''])).to eq('')
+ end
+
+ it 'should return :undef if it is the last possibility' do
+ expect(scope.function_pick_default(['', :undefined, :undef])).to eq(:undef)
+ end
+
+ it 'should return :undefined if it is the last possibility' do
+ expect(scope.function_pick_default([:undef, '', :undefined])).to eq(:undefined)
+ end
+
+ it 'should return the empty string if it is the only possibility' do
+ expect(scope.function_pick_default([''])).to eq('')
+ end
+
+ it 'should return :undef if it is the only possibility' do
+ expect(scope.function_pick_default([:undef])).to eq(:undef)
+ end
+
+ it 'should return :undefined if it is the only possibility' do
+ expect(scope.function_pick_default([:undefined])).to eq(:undefined)
+ end
+
+ it 'should error if no values are passed' do
+ expect { scope.function_pick_default([]) }.to raise_error(Puppet::Error, /Must receive at least one argument./)
+ end
+end
--- /dev/null
+#!/usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the pick function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("pick")).to eq("function_pick")
+ end
+
+ it 'should return the correct value' do
+ expect(scope.function_pick(['first', 'second'])).to eq('first')
+ end
+
+ it 'should return the correct value if the first value is empty' do
+ expect(scope.function_pick(['', 'second'])).to eq('second')
+ end
+
+ it 'should remove empty string values' do
+ expect(scope.function_pick(['', 'first'])).to eq('first')
+ end
+
+ it 'should remove :undef values' do
+ expect(scope.function_pick([:undef, 'first'])).to eq('first')
+ end
+
+ it 'should remove :undefined values' do
+ expect(scope.function_pick([:undefined, 'first'])).to eq('first')
+ end
+
+ it 'should error if no values are passed' do
+ expect { scope.function_pick([]) }.to( raise_error(Puppet::ParseError, "pick(): must receive at least one non empty value"))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the prefix function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "raises a ParseError if there is less than 1 arguments" do
+ expect { scope.function_prefix([]) }.to raise_error(Puppet::ParseError, /number of arguments/)
+ end
+
+ it "raises an error if the first argument is not an array" do
+ expect {
+ scope.function_prefix([Object.new])
+ }.to raise_error(Puppet::ParseError, /expected first argument to be an Array/)
+ end
+
+
+ it "raises an error if the second argument is not a string" do
+ expect {
+ scope.function_prefix([['first', 'second'], 42])
+ }.to raise_error(Puppet::ParseError, /expected second argument to be a String/)
+ end
+
+ it "returns a prefixed array" do
+ result = scope.function_prefix([['a','b','c'], 'p'])
+ expect(result).to(eq(['pa','pb','pc']))
+ end
+
+ it "returns a prefixed hash" do
+ result = scope.function_prefix([{'a' => 'b','b' => 'c','c' => 'd'}, 'p'])
+ expect(result).to(eq({'pa'=>'b','pb'=>'c','pc'=>'d'}))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:private) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ subject do
+ function_name = Puppet::Parser::Functions.function(:private)
+ scope.method(function_name)
+ end
+
+ it 'should issue a warning' do
+ scope.expects(:warning).with("private() DEPRECATED: This function will cease to function on Puppet 4; please use assert_private() before upgrading to puppet 4 for backwards-compatibility, or migrate to the new parser's typing system.")
+ subject.call []
+ end
+
+ context "when called from inside module" do
+ it "should not fail" do
+ scope.expects(:lookupvar).with('module_name').returns('foo')
+ scope.expects(:lookupvar).with('caller_module_name').returns('foo')
+ expect {
+ subject.call []
+ }.not_to raise_error
+ end
+ end
+
+ context "with an explicit failure message" do
+ it "prints the failure message on error" do
+ scope.expects(:lookupvar).with('module_name').returns('foo')
+ scope.expects(:lookupvar).with('caller_module_name').returns('bar')
+ expect {
+ subject.call ['failure message!']
+ }.to raise_error Puppet::ParseError, /failure message!/
+ end
+ end
+
+ context "when called from private class" do
+ it "should fail with a class error message" do
+ scope.expects(:lookupvar).with('module_name').returns('foo')
+ scope.expects(:lookupvar).with('caller_module_name').returns('bar')
+ scope.source.expects(:name).returns('foo::baz')
+ scope.source.expects(:type).returns('hostclass')
+ expect {
+ subject.call []
+ }.to raise_error Puppet::ParseError, /Class foo::baz is private/
+ end
+ end
+
+ context "when called from private definition" do
+ it "should fail with a class error message" do
+ scope.expects(:lookupvar).with('module_name').returns('foo')
+ scope.expects(:lookupvar).with('caller_module_name').returns('bar')
+ scope.source.expects(:name).returns('foo::baz')
+ scope.source.expects(:type).returns('definition')
+ expect {
+ subject.call []
+ }.to raise_error Puppet::ParseError, /Definition foo::baz is private/
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the pw_hash function" do
+
+ before :all do
+ @enhanced_salts_supported = RUBY_PLATFORM == 'java'
+ end
+
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("pw_hash")).to eq("function_pw_hash")
+ end
+
+ it "should raise an ArgumentError if there are less than 3 arguments" do
+ expect { scope.function_pw_hash([]) }.to( raise_error(ArgumentError, /[Ww]rong number of arguments/) )
+ expect { scope.function_pw_hash(['password']) }.to( raise_error(ArgumentError, /[Ww]rong number of arguments/) )
+ expect { scope.function_pw_hash(['password', 'sha-512']) }.to( raise_error(ArgumentError, /[Ww]rong number of arguments/) )
+ end
+
+ it "should raise an ArgumentError if there are more than 3 arguments" do
+ expect { scope.function_pw_hash(['password', 'sha-512', 'salt', 5]) }.to( raise_error(ArgumentError, /[Ww]rong number of arguments/) )
+ end
+
+ it "should raise an ArgumentError if the first argument is not a string" do
+ expect { scope.function_pw_hash([['password'], 'sha-512', 'salt']) }.to( raise_error(ArgumentError, /first argument must be a string/) )
+ # in Puppet 3, numbers are passed as strings, so we can't test that
+ end
+
+ it "should return nil if the first argument is empty" do
+ expect(scope.function_pw_hash(['', 'sha-512', 'salt'])).to eq(nil)
+ end
+
+ it "should return nil if the first argument is undef" do
+ expect(scope.function_pw_hash([nil, 'sha-512', 'salt'])).to eq(nil)
+ end
+
+ it "should raise an ArgumentError if the second argument is an invalid hash type" do
+ expect { scope.function_pw_hash(['', 'invalid', 'salt']) }.to( raise_error(ArgumentError, /not a valid hash type/) )
+ end
+
+ it "should raise an ArgumentError if the second argument is not a string" do
+ expect { scope.function_pw_hash(['', [], 'salt']) }.to( raise_error(ArgumentError, /second argument must be a string/) )
+ end
+
+ it "should raise an ArgumentError if the third argument is not a string" do
+ expect { scope.function_pw_hash(['password', 'sha-512', ['salt']]) }.to( raise_error(ArgumentError, /third argument must be a string/) )
+ # in Puppet 3, numbers are passed as strings, so we can't test that
+ end
+
+ it "should raise an ArgumentError if the third argument is empty" do
+ expect { scope.function_pw_hash(['password', 'sha-512', '']) }.to( raise_error(ArgumentError, /third argument must not be empty/) )
+ end
+
+ it "should raise an ArgumentError if the third argument has invalid characters" do
+ expect { scope.function_pw_hash(['password', 'sha-512', '%']) }.to( raise_error(ArgumentError, /characters in salt must be in the set/) )
+ end
+
+ it "should fail on platforms with weak implementations of String#crypt" do
+ String.any_instance.expects(:crypt).with('$1$1').returns('$1SoNol0Ye6Xk')
+ expect { scope.function_pw_hash(['password', 'sha-512', 'salt']) }.to( raise_error(Puppet::ParseError, /system does not support enhanced salts/) )
+ end
+
+ if @enhanced_salts_supported
+ describe "on systems with enhanced salts support" do
+ it "should return a hashed password" do
+ result = scope.function_pw_hash(['password', 'sha-512', 'salt'])
+ expect(result).to eql('$6$salt$IxDD3jeSOb5eB1CX5LBsqZFVkJdido3OUILO5Ifz5iwMuTS4XMS130MTSuDDl3aCI6WouIL9AjRbLCelDCy.g.')
+ end
+
+ it "should use the specified salt" do
+ result = scope.function_pw_hash(['password', 'sha-512', 'salt'])
+ expect(result).to match('salt')
+ end
+
+ it "should use the specified hash type" do
+ resultmd5 = scope.function_pw_hash(['password', 'md5', 'salt'])
+ resultsha256 = scope.function_pw_hash(['password', 'sha-256', 'salt'])
+ resultsha512 = scope.function_pw_hash(['password', 'sha-512', 'salt'])
+
+ expect(resultmd5).to eql('$1$salt$qJH7.N4xYta3aEG/dfqo/0')
+ expect(resultsha256).to eql('$5$salt$Gcm6FsVtF/Qa77ZKD.iwsJlCVPY0XSMgLJL0Hnww/c1')
+ expect(resultsha512).to eql('$6$salt$IxDD3jeSOb5eB1CX5LBsqZFVkJdido3OUILO5Ifz5iwMuTS4XMS130MTSuDDl3aCI6WouIL9AjRbLCelDCy.g.')
+ end
+
+ it "should generate a valid hash" do
+ password_hash = scope.function_pw_hash(['password', 'sha-512', 'salt'])
+
+ hash_parts = password_hash.match(%r{\A\$(.*)\$([a-zA-Z0-9./]+)\$([a-zA-Z0-9./]+)\z})
+
+ expect(hash_parts).not_to eql(nil)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the range function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "exists" do
+ expect(Puppet::Parser::Functions.function("range")).to eq("function_range")
+ end
+
+ it "raises a ParseError if there is less than 1 arguments" do
+ expect { scope.function_range([]) }.to raise_error Puppet::ParseError, /Wrong number of arguments.*0 for 1/
+ end
+
+ describe 'with a letter range' do
+ it "returns a letter range" do
+ result = scope.function_range(["a","d"])
+ expect(result).to eq ['a','b','c','d']
+ end
+
+ it "returns a letter range given a step of 1" do
+ result = scope.function_range(["a","d","1"])
+ expect(result).to eq ['a','b','c','d']
+ end
+
+ it "returns a stepped letter range" do
+ result = scope.function_range(["a","d","2"])
+ expect(result).to eq ['a','c']
+ end
+
+ it "returns a stepped letter range given a negative step" do
+ result = scope.function_range(["a","d","-2"])
+ expect(result).to eq ['a','c']
+ end
+ end
+
+ describe 'with a number range' do
+ it "returns a number range" do
+ result = scope.function_range(["1","4"])
+ expect(result).to eq [1,2,3,4]
+ end
+
+ it "returns a number range given a step of 1" do
+ result = scope.function_range(["1","4","1"])
+ expect(result).to eq [1,2,3,4]
+ end
+
+ it "returns a stepped number range" do
+ result = scope.function_range(["1","4","2"])
+ expect(result).to eq [1,3]
+ end
+
+ it "returns a stepped number range given a negative step" do
+ result = scope.function_range(["1","4","-2"])
+ expect(result).to eq [1,3]
+ end
+ end
+
+ describe 'with a numeric-like string range' do
+ it "works with padded hostname like strings" do
+ expected = ("host01".."host10").to_a
+ expect(scope.function_range(["host01","host10"])).to eq expected
+ end
+
+ it "coerces zero padded digits to integers" do
+ expected = (0..10).to_a
+ expect(scope.function_range(["00", "10"])).to eq expected
+ end
+ end
+
+ describe 'with a numeric range' do
+ it "returns a range of numbers" do
+ expected = (1..10).to_a
+ expect(scope.function_range([1,10])).to eq expected
+ end
+ it "returns a range of numbers with step parameter" do
+ expected = (1..10).step(2).to_a
+ expect(scope.function_range([1,10,2])).to eq expected
+ end
+ it "works with mixed numeric like strings and numeric arguments" do
+ expected = (1..10).to_a
+ expect(scope.function_range(['1',10])).to eq expected
+ expect(scope.function_range([1,'10'])).to eq expected
+ end
+ end
+end
--- /dev/null
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+describe "the reject function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("reject")).to eq("function_reject")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_reject([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should reject contents from an array" do
+ result = scope.function_reject([["1111", "aaabbb","bbbccc","dddeee"], "bbb"])
+ expect(result).to(eq(["1111", "dddeee"]))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the reverse function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("reverse")).to eq("function_reverse")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_reverse([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should reverse a string" do
+ result = scope.function_reverse(["asdfghijkl"])
+ expect(result).to(eq('lkjihgfdsa'))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new('asdfghjkl')
+ result = scope.function_reverse([value])
+ result.should(eq('lkjhgfdsa'))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the rstrip function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("rstrip")).to eq("function_rstrip")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_rstrip([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should rstrip a string" do
+ result = scope.function_rstrip(["asdf "])
+ expect(result).to(eq('asdf'))
+ end
+
+ it "should rstrip each element in an array" do
+ result = scope.function_rstrip([["a ","b ", "c "]])
+ expect(result).to(eq(['a','b','c']))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new('asdf ')
+ result = scope.function_rstrip([value])
+ result.should(eq('asdf'))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the shuffle function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("shuffle")).to eq("function_shuffle")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_shuffle([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should shuffle a string and the result should be the same size" do
+ result = scope.function_shuffle(["asdf"])
+ expect(result.size).to(eq(4))
+ end
+
+ it "should shuffle a string but the sorted contents should still be the same" do
+ result = scope.function_shuffle(["adfs"])
+ expect(result.split("").sort.join("")).to(eq("adfs"))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new('asdf')
+ result = scope.function_shuffle([value])
+ result.size.should(eq(4))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the size function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("size")).to eq("function_size")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_size([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return the size of a string" do
+ result = scope.function_size(["asdf"])
+ expect(result).to(eq(4))
+ end
+
+ it "should return the size of an array" do
+ result = scope.function_size([["a","b","c"]])
+ expect(result).to(eq(3))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the sort function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("sort")).to eq("function_sort")
+ end
+
+ it "should raise a ParseError if there is not 1 arguments" do
+ expect { scope.function_sort(['','']) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should sort an array" do
+ result = scope.function_sort([["a","c","b"]])
+ expect(result).to(eq(['a','b','c']))
+ end
+
+ it "should sort a string" do
+ result = scope.function_sort(["acb"])
+ expect(result).to(eq('abc'))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the squeeze function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("squeeze")).to eq("function_squeeze")
+ end
+
+ it "should raise a ParseError if there is less than 2 arguments" do
+ expect { scope.function_squeeze([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should squeeze a string" do
+ result = scope.function_squeeze(["aaabbbbcccc"])
+ expect(result).to(eq('abc'))
+ end
+
+ it "should squeeze all elements in an array" do
+ result = scope.function_squeeze([["aaabbbbcccc","dddfff"]])
+ expect(result).to(eq(['abc','df']))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the str2bool function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("str2bool")).to eq("function_str2bool")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_str2bool([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should convert string 'true' to true" do
+ result = scope.function_str2bool(["true"])
+ expect(result).to(eq(true))
+ end
+
+ it "should convert string 'undef' to false" do
+ result = scope.function_str2bool(["undef"])
+ expect(result).to(eq(false))
+ end
+
+ it "should return the boolean it was called with" do
+ result = scope.function_str2bool([true])
+ expect(result).to(eq(true))
+ result = scope.function_str2bool([false])
+ expect(result).to(eq(false))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the str2saltedsha512 function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("str2saltedsha512")).to eq("function_str2saltedsha512")
+ end
+
+ it "should raise a ParseError if there is less than 1 argument" do
+ expect { scope.function_str2saltedsha512([]) }.to( raise_error(Puppet::ParseError) )
+ end
+
+ it "should raise a ParseError if there is more than 1 argument" do
+ expect { scope.function_str2saltedsha512(['foo', 'bar', 'baz']) }.to( raise_error(Puppet::ParseError) )
+ end
+
+ it "should return a salted-sha512 password hash 136 characters in length" do
+ result = scope.function_str2saltedsha512(["password"])
+ expect(result.length).to(eq(136))
+ end
+
+ it "should raise an error if you pass a non-string password" do
+ expect { scope.function_str2saltedsha512([1234]) }.to( raise_error(Puppet::ParseError) )
+ end
+
+ it "should generate a valid password" do
+ # Allow the function to generate a password based on the string 'password'
+ password_hash = scope.function_str2saltedsha512(["password"])
+
+ # Separate the Salt and Password from the Password Hash
+ salt = password_hash[0..7]
+ password = password_hash[8..-1]
+
+ # Convert the Salt and Password from Hex to Binary Data
+ str_salt = Array(salt.lines).pack('H*')
+ str_password = Array(password.lines).pack('H*')
+
+ # Combine the Binary Salt with 'password' and compare the end result
+ saltedpass = Digest::SHA512.digest(str_salt + 'password')
+ result = (str_salt + saltedpass).unpack('H*')[0]
+ expect(result).to eq(password_hash)
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the strftime function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("strftime")).to eq("function_strftime")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_strftime([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "using %s should be higher then when I wrote this test" do
+ result = scope.function_strftime(["%s"])
+ expect(result.to_i).to(be > 1311953157)
+ end
+
+ it "using %s should be lower then 1.5 trillion" do
+ result = scope.function_strftime(["%s"])
+ expect(result.to_i).to(be < 1500000000)
+ end
+
+ it "should return a date when given %Y-%m-%d" do
+ result = scope.function_strftime(["%Y-%m-%d"])
+ expect(result).to match(/^\d{4}-\d{2}-\d{2}$/)
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the strip function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("strip")).to eq("function_strip")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_strip([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should strip a string" do
+ result = scope.function_strip([" ab cd "])
+ expect(result).to(eq('ab cd'))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new(' as df ')
+ result = scope.function_strip([value])
+ result.should(eq('as df'))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the suffix function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "raises a ParseError if there is less than 1 arguments" do
+ expect { scope.function_suffix([]) }.to raise_error(Puppet::ParseError, /number of arguments/)
+ end
+
+ it "raises an error if the first argument is not an array" do
+ expect {
+ scope.function_suffix([Object.new])
+ }.to raise_error(Puppet::ParseError, /expected first argument to be an Array/)
+ end
+
+ it "raises an error if the second argument is not a string" do
+ expect {
+ scope.function_suffix([['first', 'second'], 42])
+ }.to raise_error(Puppet::ParseError, /expected second argument to be a String/)
+ end
+
+ it "returns a suffixed array" do
+ result = scope.function_suffix([['a','b','c'], 'p'])
+ expect(result).to(eq(['ap','bp','cp']))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the swapcase function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("swapcase")).to eq("function_swapcase")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_swapcase([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should swapcase a string" do
+ result = scope.function_swapcase(["aaBBccDD"])
+ expect(result).to(eq('AAbbCCdd'))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new("aaBBccDD")
+ result = scope.function_swapcase([value])
+ result.should(eq("AAbbCCdd"))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the time function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("time")).to eq("function_time")
+ end
+
+ it "should raise a ParseError if there is more than 2 arguments" do
+ expect { scope.function_time(['','']) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return a number" do
+ result = scope.function_time([])
+ expect(result).to be_an(Integer)
+ end
+
+ it "should be higher then when I wrote this test" do
+ result = scope.function_time([])
+ expect(result).to(be > 1311953157)
+ end
+
+ it "should be lower then 1.5 trillion" do
+ result = scope.function_time([])
+ expect(result).to(be < 1500000000)
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the to_bytes function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("to_bytes")).to eq("function_to_bytes")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_to_bytes([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should convert kB to B" do
+ result = scope.function_to_bytes(["4 kB"])
+ expect(result).to(eq(4096))
+ end
+
+ it "should convert MB to B" do
+ result = scope.function_to_bytes(["4 MB"])
+ expect(result).to(eq(4194304))
+ end
+
+ it "should convert GB to B" do
+ result = scope.function_to_bytes(["4 GB"])
+ expect(result).to(eq(4294967296))
+ end
+
+ it "should convert TB to B" do
+ result = scope.function_to_bytes(["4 TB"])
+ expect(result).to(eq(4398046511104))
+ end
+
+ it "should convert PB to B" do
+ result = scope.function_to_bytes(["4 PB"])
+ expect(result).to(eq(4503599627370496))
+ end
+
+ it "should convert PB to B" do
+ result = scope.function_to_bytes(["4 EB"])
+ expect(result).to(eq(4611686018427387904))
+ end
+
+ it "should work without B in unit" do
+ result = scope.function_to_bytes(["4 k"])
+ expect(result).to(eq(4096))
+ end
+
+ it "should work without a space before unit" do
+ result = scope.function_to_bytes(["4k"])
+ expect(result).to(eq(4096))
+ end
+
+ it "should work without a unit" do
+ result = scope.function_to_bytes(["5678"])
+ expect(result).to(eq(5678))
+ end
+
+ it "should convert fractions" do
+ result = scope.function_to_bytes(["1.5 kB"])
+ expect(result).to(eq(1536))
+ end
+
+ it "should convert scientific notation" do
+ result = scope.function_to_bytes(["1.5e2 B"])
+ expect(result).to(eq(150))
+ end
+
+ it "should do nothing with a positive number" do
+ result = scope.function_to_bytes([5678])
+ expect(result).to(eq(5678))
+ end
+
+ it "should should raise a ParseError if input isn't a number" do
+ expect { scope.function_to_bytes(["foo"]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should should raise a ParseError if prefix is unknown" do
+ expect { scope.function_to_bytes(["5 uB"]) }.to( raise_error(Puppet::ParseError))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the type3x function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("type3x")).to eq("function_type3x")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_type3x([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return string when given a string" do
+ result = scope.function_type3x(["aaabbbbcccc"])
+ expect(result).to(eq('string'))
+ end
+
+ it "should return array when given an array" do
+ result = scope.function_type3x([["aaabbbbcccc","asdf"]])
+ expect(result).to(eq('array'))
+ end
+
+ it "should return hash when given a hash" do
+ result = scope.function_type3x([{"a"=>1,"b"=>2}])
+ expect(result).to(eq('hash'))
+ end
+
+ it "should return integer when given an integer" do
+ result = scope.function_type3x(["1"])
+ expect(result).to(eq('integer'))
+ end
+
+ it "should return float when given a float" do
+ result = scope.function_type3x(["1.34"])
+ expect(result).to(eq('float'))
+ end
+
+ it "should return boolean when given a boolean" do
+ result = scope.function_type3x([true])
+ expect(result).to(eq('boolean'))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the type function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("type")).to eq("function_type")
+ end
+
+ it "should give a deprecation warning when called" do
+ scope.expects(:warning).with("type() DEPRECATED: This function will cease to function on Puppet 4; please use type3x() before upgrading to puppet 4 for backwards-compatibility, or migrate to the new parser's typing system.")
+ scope.function_type(["aoeu"])
+ end
+
+ it "should return string when given a string" do
+ result = scope.function_type(["aaabbbbcccc"])
+ expect(result).to(eq('string'))
+ end
+
+ it "should return array when given an array" do
+ result = scope.function_type([["aaabbbbcccc","asdf"]])
+ expect(result).to(eq('array'))
+ end
+
+ it "should return hash when given a hash" do
+ result = scope.function_type([{"a"=>1,"b"=>2}])
+ expect(result).to(eq('hash'))
+ end
+
+ it "should return integer when given an integer" do
+ result = scope.function_type(["1"])
+ expect(result).to(eq('integer'))
+ end
+
+ it "should return float when given a float" do
+ result = scope.function_type(["1.34"])
+ expect(result).to(eq('float'))
+ end
+
+ it "should return boolean when given a boolean" do
+ result = scope.function_type([true])
+ expect(result).to(eq('boolean'))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the union function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("union")).to eq("function_union")
+ end
+
+ it "should raise a ParseError if there are fewer than 2 arguments" do
+ expect { scope.function_union([]) }.to( raise_error(Puppet::ParseError) )
+ end
+
+ it "should join two arrays together" do
+ result = scope.function_union([["a","b","c"],["b","c","d"]])
+ expect(result).to(eq(["a","b","c","d"]))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the unique function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("unique")).to eq("function_unique")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_unique([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should remove duplicate elements in a string" do
+ result = scope.function_unique(["aabbc"])
+ expect(result).to(eq('abc'))
+ end
+
+ it "should remove duplicate elements in an array" do
+ result = scope.function_unique([["a","a","b","b","c"]])
+ expect(result).to(eq(['a','b','c']))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new('aabbc')
+ result = scope.function_unique([value])
+ result.should(eq('abc'))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the upcase function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("upcase")).to eq("function_upcase")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_upcase([]) }.to(raise_error(Puppet::ParseError))
+ end
+
+ it "should upcase a string" do
+ result = scope.function_upcase(["abc"])
+ expect(result).to(eq('ABC'))
+ end
+
+ it "should do nothing if a string is already upcase" do
+ result = scope.function_upcase(["ABC"])
+ expect(result).to(eq('ABC'))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new('abc')
+ result = scope.function_upcase([value])
+ result.should(eq('ABC'))
+ end
+
+ it 'should accept hashes and return uppercase' do
+ expect(
+ scope.function_upcase([{'test' => %w(this that and other thing)}])
+ ).to eq({'TEST' => %w(THIS THAT AND OTHER THING)})
+ end
+
+ if :test.respond_to?(:upcase)
+ it 'should accept hashes of symbols' do
+ expect(
+ scope.function_upcase([{:test => [:this, :that, :other]}])
+ ).to eq({:TEST => [:THIS, :THAT, :OTHER]})
+ end
+ it 'should return upcase symbol' do
+ expect(
+ scope.function_upcase([:test])
+ ).to eq(:TEST)
+ end
+ it 'should return mixed objects in upcease' do
+ expect(
+ scope.function_upcase([[:test, 'woot']])
+ ).to eq([:TEST, 'WOOT'])
+
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the uriescape function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("uriescape")).to eq("function_uriescape")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_uriescape([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should uriescape a string" do
+ result = scope.function_uriescape([":/?#[]@!$&'()*+,;= \"{}"])
+ expect(result).to(eq(':/?%23[]@!$&\'()*+,;=%20%22%7B%7D'))
+ end
+
+ it "should uriescape an array of strings, while not touching up nonstrings" do
+ teststring = ":/?#[]@!$&'()*+,;= \"{}"
+ expectstring = ':/?%23[]@!$&\'()*+,;=%20%22%7B%7D'
+ result = scope.function_uriescape([[teststring, teststring, 1]])
+ expect(result).to(eq([expectstring, expectstring, 1]))
+ end
+
+ it "should do nothing if a string is already safe" do
+ result = scope.function_uriescape(["ABCdef"])
+ expect(result).to(eq('ABCdef'))
+ end
+
+ it "should accept objects which extend String" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new('abc')
+ result = scope.function_uriescape([value])
+ result.should(eq('abc'))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:validate_absolute_path) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ # The subject of these examples is the method itself.
+ subject do
+ # This makes sure the function is loaded within each test
+ function_name = Puppet::Parser::Functions.function(:validate_absolute_path)
+ scope.method(function_name)
+ end
+
+ describe "Valid Paths" do
+ def self.valid_paths
+ %w{
+ C:/
+ C:\\
+ C:\\WINDOWS\\System32
+ C:/windows/system32
+ X:/foo/bar
+ X:\\foo\\bar
+ /var/tmp
+ /var/lib/puppet
+ /var/opt/../lib/puppet
+ }
+ end
+
+ context "Without Puppet::Util.absolute_path? (e.g. Puppet <= 2.6)" do
+ before :each do
+ # The intent here is to mock Puppet to behave like Puppet 2.6 does.
+ # Puppet 2.6 does not have the absolute_path? method. This is only a
+ # convenience test, stdlib should be run with the Puppet 2.6.x in the
+ # $LOAD_PATH in addition to 2.7.x and master.
+ Puppet::Util.expects(:respond_to?).with(:absolute_path?).returns(false)
+ end
+ valid_paths.each do |path|
+ it "validate_absolute_path(#{path.inspect}) should not fail" do
+ expect { subject.call [path] }.not_to raise_error
+ end
+ end
+ valid_paths do
+ it "validate_absolute_path(#{valid_paths.inspect}) should not fail" do
+ expect { subject.call [valid_paths] }.not_to raise_error
+ end
+ end
+ end
+
+ context "Puppet without mocking" do
+ valid_paths.each do |path|
+ it "validate_absolute_path(#{path.inspect}) should not fail" do
+ expect { subject.call [path] }.not_to raise_error
+ end
+ end
+ valid_paths do
+ it "validate_absolute_path(#{valid_paths.inspect}) should not fail" do
+ expect { subject.call [valid_paths] }.not_to raise_error
+ end
+ end
+ end
+ end
+
+ describe 'Invalid paths' do
+ context 'Garbage inputs' do
+ [
+ nil,
+ [ nil ],
+ [ nil, nil ],
+ { 'foo' => 'bar' },
+ { },
+ '',
+ ].each do |path|
+ it "validate_absolute_path(#{path.inspect}) should fail" do
+ expect { subject.call [path] }.to raise_error Puppet::ParseError
+ end
+ end
+ end
+
+ context 'Relative paths' do
+ def self.rel_paths
+ %w{
+ relative1
+ .
+ ..
+ ./foo
+ ../foo
+ etc/puppetlabs/puppet
+ opt/puppet/bin
+ }
+ end
+ rel_paths.each do |path|
+ it "validate_absolute_path(#{path.inspect}) should fail" do
+ expect { subject.call [path] }.to raise_error Puppet::ParseError
+ end
+ end
+ rel_paths do
+ it "validate_absolute_path(#{rel_paths.inspect}) should fail" do
+ expect { subject.call [rel_paths] }.to raise_error Puppet::ParseError
+ end
+ end
+ end
+ end
+end
+
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:validate_array) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+ describe 'when calling validate_array from puppet' do
+
+ %w{ true false }.each do |the_string|
+ it "should not compile when #{the_string} is a string" do
+ Puppet[:code] = "validate_array('#{the_string}')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /is not an Array/)
+ end
+
+ it "should not compile when #{the_string} is a bare word" do
+ Puppet[:code] = "validate_array(#{the_string})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /is not an Array/)
+ end
+ end
+
+ it "should compile when multiple array arguments are passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = [ ]
+ $bar = [ 'one', 'two' ]
+ validate_array($foo, $bar)
+ ENDofPUPPETcode
+ scope.compiler.compile
+ end
+
+ it "should not compile when an undef variable is passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = undef
+ validate_array($foo)
+ ENDofPUPPETcode
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /is not an Array/)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:validate_augeas), :if => Puppet.features.augeas? do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ # The subject of these examplres is the method itself.
+ subject do
+ # This makes sure the function is loaded within each test
+ function_name = Puppet::Parser::Functions.function(:validate_augeas)
+ scope.method(function_name)
+ end
+
+ context 'Using Puppet::Parser::Scope.new' do
+
+ describe 'Garbage inputs' do
+ inputs = [
+ [ nil ],
+ [ [ nil ] ],
+ [ { 'foo' => 'bar' } ],
+ [ { } ],
+ [ '' ],
+ [ "one", "one", "MSG to User", "4th arg" ],
+ ]
+
+ inputs.each do |input|
+ it "validate_augeas(#{input.inspect}) should fail" do
+ expect { subject.call [input] }.to raise_error Puppet::ParseError
+ end
+ end
+ end
+
+ describe 'Valid inputs' do
+ inputs = [
+ [ "root:x:0:0:root:/root:/bin/bash\n", 'Passwd.lns' ],
+ [ "proc /proc proc nodev,noexec,nosuid 0 0\n", 'Fstab.lns'],
+ ]
+
+ inputs.each do |input|
+ it "validate_augeas(#{input.inspect}) should not fail" do
+ expect { subject.call input }.not_to raise_error
+ end
+ end
+ end
+
+ describe "Valid inputs which should raise an exception without a message" do
+ # The intent here is to make sure valid inputs raise exceptions when they
+ # don't specify an error message to display. This is the behvior in
+ # 2.2.x and prior.
+ inputs = [
+ [ "root:x:0:0:root\n", 'Passwd.lns' ],
+ [ "127.0.1.1\n", 'Hosts.lns' ],
+ ]
+
+ inputs.each do |input|
+ it "validate_augeas(#{input.inspect}) should fail" do
+ expect { subject.call input }.to raise_error /validate_augeas.*?matched less than it should/
+ end
+ end
+ end
+
+ describe "Nicer Error Messages" do
+ # The intent here is to make sure the function returns the 4th argument
+ # in the exception thrown
+ inputs = [
+ [ "root:x:0:0:root\n", 'Passwd.lns', [], 'Failed to validate passwd content' ],
+ [ "127.0.1.1\n", 'Hosts.lns', [], 'Wrong hosts content' ],
+ ]
+
+ inputs.each do |input|
+ it "validate_augeas(#{input.inspect}) should fail" do
+ expect { subject.call input }.to raise_error /#{input[3]}/
+ end
+ end
+ end
+
+ describe "Passing simple unit tests" do
+ inputs = [
+ [ "root:x:0:0:root:/root:/bin/bash\n", 'Passwd.lns', ['$file/foobar']],
+ [ "root:x:0:0:root:/root:/bin/bash\n", 'Passwd.lns', ['$file/root/shell[.="/bin/sh"]', 'foobar']],
+ ]
+
+ inputs.each do |input|
+ it "validate_augeas(#{input.inspect}) should fail" do
+ expect { subject.call input }.not_to raise_error
+ end
+ end
+ end
+
+ describe "Failing simple unit tests" do
+ inputs = [
+ [ "foobar:x:0:0:root:/root:/bin/bash\n", 'Passwd.lns', ['$file/foobar']],
+ [ "root:x:0:0:root:/root:/bin/sh\n", 'Passwd.lns', ['$file/root/shell[.="/bin/sh"]', 'foobar']],
+ ]
+
+ inputs.each do |input|
+ it "validate_augeas(#{input.inspect}) should fail" do
+ expect { subject.call input }.to raise_error /testing path/
+ end
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:validate_bool) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+ describe 'when calling validate_bool from puppet' do
+
+ %w{ true false }.each do |the_string|
+
+ it "should not compile when #{the_string} is a string" do
+ Puppet[:code] = "validate_bool('#{the_string}')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /is not a boolean/)
+ end
+
+ it "should compile when #{the_string} is a bare word" do
+ Puppet[:code] = "validate_bool(#{the_string})"
+ scope.compiler.compile
+ end
+
+ end
+
+ it "should not compile when an arbitrary string is passed" do
+ Puppet[:code] = 'validate_bool("jeff and dan are awesome")'
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /is not a boolean/)
+ end
+
+ it "should not compile when no arguments are passed" do
+ Puppet[:code] = 'validate_bool()'
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+ end
+
+ it "should compile when multiple boolean arguments are passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = true
+ $bar = false
+ validate_bool($foo, $bar, true, false)
+ ENDofPUPPETcode
+ scope.compiler.compile
+ end
+
+ it "should compile when multiple boolean arguments are passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = true
+ $bar = false
+ validate_bool($foo, $bar, true, false, 'jeff')
+ ENDofPUPPETcode
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /is not a boolean/)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+TESTEXE = File.exists?('/usr/bin/test') ? '/usr/bin/test' : '/bin/test'
+TOUCHEXE = File.exists?('/usr/bin/touch') ? '/usr/bin/touch' : '/bin/touch'
+
+describe Puppet::Parser::Functions.function(:validate_cmd) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ subject do
+ function_name = Puppet::Parser::Functions.function(:validate_cmd)
+ scope.method(function_name)
+ end
+
+ context 'with no % placeholder' do
+ describe "with an explicit failure message" do
+ it "prints the failure message on error" do
+ expect {
+ subject.call ['', '/bin/false', 'failure message!']
+ }.to raise_error Puppet::ParseError, /failure message!/
+ end
+ end
+
+ describe "on validation failure" do
+ it "includes the command error output" do
+ expect {
+ subject.call ['', "#{TOUCHEXE} /cant/touch/this"]
+ }.to raise_error Puppet::ParseError, /(cannot touch|o such file or)/
+ end
+
+ it "includes the command return value" do
+ expect {
+ subject.call ['', '/cant/run/this']
+ }.to raise_error Puppet::ParseError, /returned 1\b/
+ end
+ end
+
+ describe "when performing actual validation" do
+ it "can positively validate file content" do
+ expect { subject.call ["non-empty", "#{TESTEXE} -s"] }.to_not raise_error
+ end
+
+ it "can negatively validate file content" do
+ expect {
+ subject.call ["", "#{TESTEXE} -s"]
+ }.to raise_error Puppet::ParseError, /failed to validate.*test -s/
+ end
+ end
+ end
+
+ context 'with % placeholder' do
+ describe "with an explicit failure message" do
+ it "prints the failure message on error" do
+ expect {
+ subject.call ['', '/bin/false % -f', 'failure message!']
+ }.to raise_error Puppet::ParseError, /failure message!/
+ end
+ end
+ describe "on validation failure" do
+ it "includes the command error output" do
+ expect {
+ subject.call ['', "#{TOUCHEXE} /cant/touch/this"]
+ }.to raise_error Puppet::ParseError, /(cannot touch|o such file or)/
+ end
+
+ it "includes the command return value" do
+ expect {
+ subject.call ['', '/cant/run/this % -z']
+ }.to raise_error Puppet::ParseError, /Execution of '\/cant\/run\/this .+ -z' returned 1/
+ end
+ end
+
+ describe "when performing actual validation" do
+ it "can positively validate file content" do
+ expect { subject.call ["non-empty", "#{TESTEXE} -s %"] }.to_not raise_error
+ end
+
+ it "can negatively validate file content" do
+ expect {
+ subject.call ["", "#{TESTEXE} -s %"]
+ }.to raise_error Puppet::ParseError, /failed to validate.*test -s/
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:validate_hash) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ describe 'when calling validate_hash from puppet' do
+
+ %w{ true false }.each do |the_string|
+
+ it "should not compile when #{the_string} is a string" do
+ Puppet[:code] = "validate_hash('#{the_string}')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /is not a Hash/)
+ end
+
+ it "should not compile when #{the_string} is a bare word" do
+ Puppet[:code] = "validate_hash(#{the_string})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /is not a Hash/)
+ end
+
+ end
+
+ it "should compile when multiple hash arguments are passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = {}
+ $bar = { 'one' => 'two' }
+ validate_hash($foo, $bar)
+ ENDofPUPPETcode
+ scope.compiler.compile
+ end
+
+ it "should not compile when an undef variable is passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = undef
+ validate_hash($foo)
+ ENDofPUPPETcode
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /is not a Hash/)
+ end
+
+ end
+
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:validate_integer) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ describe 'when calling validate_integer from puppet without any argument or to many' do
+ it "should not compile when no argument is passed" do
+ Puppet[:code] = "validate_integer()"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /Wrong number of arguments/)
+ end
+ it "should not compile when more than three arguments are passed" do
+ Puppet[:code] = "validate_integer(1, 1, 1, 1)"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /Wrong number of arguments/)
+ end
+ end
+
+ describe 'when calling validate_integer from puppet only with input' do
+ %w{ 1 -1 }.each do |the_number|
+ it "should compile when #{the_number} is an encapsulated integer" do
+ Puppet[:code] = "validate_integer('#{the_number}')"
+ scope.compiler.compile
+ end
+ it "should compile when #{the_number} is an bare integer" do
+ Puppet[:code] = "validate_integer(#{the_number})"
+ scope.compiler.compile
+ end
+ end
+
+ %w{ [1,2,3,4,5] ['1','2','3','4','5'] }.each do |the_number|
+ it "should compile when multiple Integer arguments are passed in an Array" do
+ Puppet[:code] = "validate_integer(#{the_number})"
+ scope.compiler.compile
+ end
+ end
+
+ %w{ true false iAmAString 1test 7.0 -7.0 }.each do |the_number|
+ it "should not compile when #{the_number} is in a string" do
+ Puppet[:code] = "validate_integer('#{the_number}')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer/)
+ end
+
+ it "should not compile when #{the_number} is a bare word" do
+ Puppet[:code] = "validate_integer(#{the_number})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer/)
+ end
+ end
+
+ it "should not compile when an Integer is part of a larger String" do
+ Puppet[:code] = "validate_integer('1 test')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer/)
+ end
+
+ it "should not compile when an Array with a non-Integer value is passed" do
+ Puppet[:code] = "validate_integer([1, '-7.0'])"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /at array position 1 to be an Integer/)
+ end
+
+ it "should not compile when a Hash is passed" do
+ Puppet[:code] = "validate_integer({ 1 => 2 })"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer or Array/)
+ end
+
+ it "should not compile when an explicitly undef variable is passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = undef
+ validate_integer($foo)
+ ENDofPUPPETcode
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer/)
+ end
+
+ it "should not compile when an undefined variable is passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ validate_integer($foobarbazishouldnotexist)
+ ENDofPUPPETcode
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer/)
+ end
+ end
+
+ describe 'when calling validate_integer from puppet with input and a maximum' do
+ max = 10
+ %w{ 1 -1 }.each do |the_number|
+ it "should compile when #{the_number} is lower than a maximum of #{max}" do
+ Puppet[:code] = "validate_integer(#{the_number},#{max})"
+ scope.compiler.compile
+ end
+ end
+
+ it "should compile when an Integer is equal the maximum" do
+ Puppet[:code] = "validate_integer(#{max},#{max})"
+ scope.compiler.compile
+ end
+
+ it "should not compile when #{max+1} is greater than a maximum of #{max}" do
+ Puppet[:code] = "validate_integer(#{max+1},#{max})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be smaller or equal to/)
+ end
+
+ %w{ [-10,1,2,3,4,5,10] ['-10','1','2','3','4','5','10'] }.each do |the_number|
+ it "should compile when each element of #{the_number} is lower than a maximum of #{max}" do
+ Puppet[:code] = "validate_integer(#{the_number},#{max})"
+ scope.compiler.compile
+ end
+ end
+
+ it "should not compile when an element of an Array [-10,1,2,3,4,5,#{max+1}] is greater than a maximum of #{max}" do
+ Puppet[:code] = "validate_integer([-10,1,2,3,4,5,#{max+1}],#{max})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be smaller or equal to/)
+ end
+
+ %w{ true false iAmAString 1test 7.0 -7.0 }.each do |the_max|
+ it "should not compile when a non-Integer maximum #{the_max}, encapsulated in a String, is passed" do
+ Puppet[:code] = "validate_integer(1,'#{the_max}')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
+ end
+
+ it "should not compile when a non-Integer maximum #{the_max} bare word is passed" do
+ Puppet[:code] = "validate_integer(1,#{the_max})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
+ end
+ end
+
+ it "should not compile when an explicitly undefined variable is passed as maximum and no minimum is passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = undef
+ validate_integer(10, $foo)
+ ENDofPUPPETcode
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
+ end
+ it "should not compile when an explicitly undef is passed as maximum and no minimum is passed" do
+ Puppet[:code] = "validate_integer(10, undef)"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
+ end
+ it "should not compile when an empty string is passed as maximum and no minimum is passed" do
+ Puppet[:code] = "validate_integer(10, '')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
+ end
+ it "should not compile when an undefined variable for a maximum is passed" do
+ Puppet[:code] = "validate_integer(10, $foobarbazishouldnotexist)"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
+ end
+ end
+
+ describe 'when calling validate_integer from puppet with input, a maximum and a minimum' do
+ it "should not compile when a minimum larger than maximum is passed" do
+ Puppet[:code] = "validate_integer(1,1,2)"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /second argument to be larger than third argument/)
+ end
+
+ max = 10
+ min = -10
+ %w{ 1 -1 }.each do |the_number|
+ it "should compile when each element of #{the_number} is within a range from #{min} to #{max}" do
+ Puppet[:code] = "validate_integer(#{the_number},#{max},#{min})"
+ scope.compiler.compile
+ end
+ end
+
+ it "should compile when an Integer is equal the minimum" do
+ Puppet[:code] = "validate_integer(#{min},#{max},#{min})"
+ scope.compiler.compile
+ end
+
+ it "should compile when an Integer is equal the minimum and maximum" do
+ Puppet[:code] = "validate_integer(#{max},#{max},#{max})"
+ scope.compiler.compile
+ end
+
+ it "should compile when an empty maximum is passed and the Integer is greater than the minimum" do
+ Puppet[:code] = "validate_integer(#{max},'',#{min})"
+ scope.compiler.compile
+ end
+ it "should compile when an explicitly undefined maximum is passed and the Integer is greater than the minimum" do
+ Puppet[:code] = "validate_integer(#{max},undef,#{min})"
+ scope.compiler.compile
+ end
+ it "should compile when an explicitly undefined variable is passed for maximum and the Integer is greater than the minimum" do
+ Puppet[:code] = <<-"ENDofPUPPETcode"
+ $foo = undef
+ validate_integer(#{max}, $foo, #{min})
+ ENDofPUPPETcode
+ scope.compiler.compile
+ end
+ it "should not compile when no maximum value is given and the Integer is greater than the minimum" do
+ Puppet[:code] = "validate_integer(#{max},,#{min})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::Error, /Syntax error at ','/)
+ end
+
+ it "should not compile when #{min-1} is lower than a minimum of #{min}" do
+ Puppet[:code] = "validate_integer(#{min-1},#{max},#{min})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be greater or equal to/)
+ end
+
+ %w{ [-10,1,2,3,4,5,10] ['-10','1','2','3','4','5','10'] }.each do |the_number|
+ it "should compile when each element of #{the_number} is within a range from #{min} to #{max}" do
+ Puppet[:code] = "validate_integer(#{the_number},#{max},#{min})"
+ scope.compiler.compile
+ end
+ end
+
+ it "should not compile when an element of an Array [#{min-1},1,2,3,4,5,10] is lower than a minimum of #{min}" do
+ Puppet[:code] = "validate_integer([#{min-1},1,2,3,4,5,10],#{max},#{min})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be greater or equal to/)
+ end
+
+ %w{ true false iAmAString 1test 7.0 -7.0 }.each do |the_min|
+ it "should not compile when a non-Integer minimum #{the_min}, encapsulated in a String, is passed" do
+ Puppet[:code] = "validate_integer(1,#{max},'#{the_min}')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
+ end
+
+ it "should not compile when a non-Integer minimum #{the_min} bare word is passed" do
+ Puppet[:code] = "validate_integer(1,#{max},#{the_min})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require "spec_helper"
+
+describe Puppet::Parser::Functions.function(:validate_ipv4_address) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ describe "when calling validate_ipv4_address from puppet" do
+ describe "when given IPv4 address strings" do
+ it "should compile with one argument" do
+ Puppet[:code] = "validate_ipv4_address('1.2.3.4')"
+ scope.compiler.compile
+ end
+
+ it "should compile with multiple arguments" do
+ Puppet[:code] = "validate_ipv4_address('1.2.3.4', '5.6.7.8')"
+ scope.compiler.compile
+ end
+ end
+
+ describe "when given an IPv6 address" do
+ it "should not compile" do
+ Puppet[:code] = "validate_ipv4_address('3ffe:505')"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /not a valid IPv4 address/)
+ end
+ end
+
+ describe "when given other strings" do
+ it "should not compile" do
+ Puppet[:code] = "validate_ipv4_address('hello', 'world')"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /not a valid IPv4 address/)
+ end
+ end
+
+ describe "when given numbers" do
+ it "should not compile" do
+ Puppet[:code] = "validate_ipv4_address(1, 2)"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /is not a valid IPv4 address/)
+ end
+ end
+
+ describe "when given booleans" do
+ it "should not compile" do
+ Puppet[:code] = "validate_ipv4_address(true, false)"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /is not a string/)
+ end
+ end
+
+ it "should not compile when no arguments are passed" do
+ Puppet[:code] = "validate_ipv4_address()"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require "spec_helper"
+
+describe Puppet::Parser::Functions.function(:validate_ipv6_address) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ describe "when calling validate_ipv6_address from puppet" do
+ describe "when given IPv6 address strings" do
+ it "should compile with one argument" do
+ Puppet[:code] = "validate_ipv6_address('3ffe:0505:0002::')"
+ scope.compiler.compile
+ end
+
+ it "should compile with multiple arguments" do
+ Puppet[:code] = "validate_ipv6_address('3ffe:0505:0002::', '3ffe:0505:0001::')"
+ scope.compiler.compile
+ end
+ end
+
+ describe "when given an ipv4 address" do
+ it "should not compile" do
+ Puppet[:code] = "validate_ipv6_address('1.2.3.4')"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /not a valid IPv6 address/)
+ end
+ end
+
+ describe "when given other strings" do
+ it "should not compile" do
+ Puppet[:code] = "validate_ipv6_address('hello', 'world')"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /not a valid IPv6 address/)
+ end
+ end
+
+ # 1.8.7 is EOL'd and also absolutely insane about ipv6
+ unless RUBY_VERSION == '1.8.7'
+ describe "when given numbers" do
+ it "should not compile" do
+ Puppet[:code] = "validate_ipv6_address(1, 2)"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /not a valid IPv6 address/)
+ end
+ end
+ end
+
+ describe "when given booleans" do
+ it "should not compile" do
+ Puppet[:code] = "validate_ipv6_address(true, false)"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /is not a string/)
+ end
+ end
+
+ it "should not compile when no arguments are passed" do
+ Puppet[:code] = "validate_ipv6_address()"
+ expect {
+ scope.compiler.compile
+ }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:validate_numeric) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ describe 'when calling validate_numeric from puppet without any argument or to many' do
+ it "should not compile when no argument is passed" do
+ Puppet[:code] = "validate_numeric()"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /Wrong number of arguments/)
+ end
+ it "should not compile when more than three arguments are passed" do
+ Puppet[:code] = "validate_numeric(1, 1, 1, 1)"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /Wrong number of arguments/)
+ end
+ end
+
+ describe 'when calling validate_numeric from puppet only with input' do
+ %w{ 1 -1 1.0 -1.0 }.each do |the_number|
+ it "should compile when #{the_number} is an encapsulated numeric" do
+ Puppet[:code] = "validate_numeric('#{the_number}')"
+ scope.compiler.compile
+ end
+ it "should compile when #{the_number} is a bare numeric" do
+ Puppet[:code] = "validate_numeric(#{the_number})"
+ scope.compiler.compile
+ end
+ end
+
+ %w{ [1,2,3,4,5] ['1','2','3','4','5'] [1.1,2.2,3.3,4.4,5.5] ['1.1','2.2','3.3','4.4','5.5'] }.each do |the_number|
+ it "should compile when multiple Numeric arguments are passed in an Array" do
+ Puppet[:code] = "validate_numeric(#{the_number})"
+ scope.compiler.compile
+ end
+ end
+
+ %w{ true false iAmAString 1test }.each do |the_number|
+ it "should not compile when #{the_number} is in a string" do
+ Puppet[:code] = "validate_numeric('#{the_number}')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric/)
+ end
+
+ it "should not compile when #{the_number} is a bare word" do
+ Puppet[:code] = "validate_numeric(#{the_number})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric/)
+ end
+ end
+
+ it "should not compile when a Numeric is part of a larger String" do
+ Puppet[:code] = "validate_numeric('1.0 test')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric/)
+ end
+
+ it "should not compile when an Array with a non-Numeric value is passed" do
+ Puppet[:code] = "validate_numeric([1, 'test'])"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /at array position 1 to be a Numeric/)
+ end
+
+ it "should not compile when a Hash is passed" do
+ Puppet[:code] = "validate_numeric({ 1 => 2 })"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric or Array/)
+ end
+
+ it "should not compile when an explicitly undef variable is passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = undef
+ validate_numeric($foo)
+ ENDofPUPPETcode
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric/)
+ end
+
+ it "should not compile when an undefined variable is passed" do
+ Puppet[:code] = 'validate_numeric($foobarbazishouldnotexist)'
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric/)
+ end
+ end
+
+ describe 'when calling validate_numeric from puppet with input and a maximum' do
+ max = 10
+ %w{ 1 -1 1.0 -1.0 }.each do |the_number|
+ it "should compile when #{the_number} is lower than a maximum of #{max}" do
+ Puppet[:code] = "validate_numeric(#{the_number},#{max})"
+ scope.compiler.compile
+ end
+ end
+
+ it "should compile when a Numeric is equal the maximum" do
+ Puppet[:code] = "validate_numeric(#{max},#{max})"
+ scope.compiler.compile
+ end
+
+ it "should not compile when #{max+1} is greater than a maximum of #{max}" do
+ Puppet[:code] = "validate_numeric(#{max+1},#{max})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be smaller or equal to/)
+ end
+
+ %w{ [-10,1,2,3,4,5,10] ['-10','1','2','3','4','5','10'] }.each do |the_number|
+ it "should compile when each element of #{the_number} is lower than a maximum of #{max}" do
+ Puppet[:code] = "validate_numeric(#{the_number},#{max})"
+ scope.compiler.compile
+ end
+ end
+
+ it "should not compile when an element of an Array [-10,1,2,3,4,5,#{max+1}] is greater than a maximum of #{max}" do
+ Puppet[:code] = "validate_numeric([-10,1,2,3,4,5,#{max+1}],#{max})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be smaller or equal to/)
+ end
+
+ %w{ true false iAmAString 1test }.each do |the_max|
+ it "should not compile when a non-Numeric maximum #{the_max}, encapsulated in a String, is passed" do
+ Puppet[:code] = "validate_numeric(1,'#{the_max}')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
+ end
+
+ it "should not compile when a non-Numeric maximum #{the_max} bare word is passed" do
+ Puppet[:code] = "validate_numeric(1,#{the_max})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
+ end
+ end
+
+ it "should not compile when an explicitly undefined variable is passed as maximum and no minimum is passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = undef
+ validate_numeric(10, $foo)
+ ENDofPUPPETcode
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
+ end
+ it "should not compile when an explicitly undef is passed as maximum and no minimum is passed" do
+ Puppet[:code] = "validate_numeric(10, undef)"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
+ end
+ it "should not compile when an empty string is passed as maximum and no minimum is passed" do
+ Puppet[:code] = "validate_numeric(10, '')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
+ end
+ it "should not compile when an undefined variable for a maximum is passed" do
+ Puppet[:code] = "validate_numeric(10, $foobarbazishouldnotexist)"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
+ end
+ end
+
+ describe 'when calling validate_numeric from puppet with input, a maximum and a minimum' do
+ it "should not compile when a minimum larger than maximum is passed" do
+ Puppet[:code] = "validate_numeric(1,1,2)"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /second argument to be larger than third argument/)
+ end
+
+ max = 10
+ min = -10
+ %w{ 1 -1 }.each do |the_number|
+ it "should compile when each element of #{the_number} is within a range from #{min} to #{max}" do
+ Puppet[:code] = "validate_numeric(#{the_number},#{max},#{min})"
+ scope.compiler.compile
+ end
+ end
+
+ it "should compile when a Numeric is equal the minimum" do
+ Puppet[:code] = "validate_numeric(#{min},#{max},#{min})"
+ scope.compiler.compile
+ end
+
+ it "should compile when a Numeric is equal the minimum and maximum" do
+ Puppet[:code] = "validate_numeric(#{max},#{max},#{max})"
+ scope.compiler.compile
+ end
+
+ it "should compile when an empty maximum is passed and the Numeric is greater than the minimum" do
+ Puppet[:code] = "validate_numeric(#{max}.1,'',#{min})"
+ scope.compiler.compile
+ end
+ it "should compile when an explicitly undefined maximum is passed and the Numeric is greater than the minimum" do
+ Puppet[:code] = "validate_numeric(#{max}.1,undef,#{min})"
+ scope.compiler.compile
+ end
+ it "should compile when an explicitly undefined variable is passed for maximum and the Numeric is greater than the minimum" do
+ Puppet[:code] = <<-"ENDofPUPPETcode"
+ $foo = undef
+ validate_numeric(#{max}.1, $foo, #{min})
+ ENDofPUPPETcode
+ scope.compiler.compile
+ end
+ it "should not compile when no maximum value is given and the Numeric is greater than the minimum" do
+ Puppet[:code] = "validate_numeric(#{max}.1,,#{min})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::Error, /Syntax error at ','/)
+ end
+
+ it "should not compile when #{min-1} is lower than a minimum of #{min}" do
+ Puppet[:code] = "validate_numeric(#{min-1.0},#{max},#{min})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be greater or equal to/)
+ end
+
+ %w{ [-10,1,2,3,4,5,10] ['-10.0','1','2','3','4','5','10.0'] }.each do |the_number|
+ it "should compile when each element of #{the_number} is within a range from #{min} to #{max}" do
+ Puppet[:code] = "validate_numeric(#{the_number},#{max},#{min})"
+ scope.compiler.compile
+ end
+ end
+
+ it "should not compile when an element of an Array [#{min-1.1},1,2,3,4,5,10.0] is lower than a minimum of #{min}" do
+ Puppet[:code] = "validate_numeric([#{min-1},1,2,3,4,5,10],#{max},#{min})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be greater or equal to/)
+ end
+
+ %w{ true false iAmAString 1test }.each do |the_min|
+ it "should not compile when a non-Numeric minimum #{the_min}, encapsulated in a String, is passed" do
+ Puppet[:code] = "validate_numeric(1,#{max},'#{the_min}')"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
+ end
+
+ it "should not compile when a non-Numeric minimum #{the_min} bare word is passed" do
+ Puppet[:code] = "validate_numeric(1,#{max},#{the_min})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/)
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:validate_re) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ # The subject of these examplres is the method itself.
+ subject do
+ # This makes sure the function is loaded within each test
+ function_name = Puppet::Parser::Functions.function(:validate_re)
+ scope.method(function_name)
+ end
+
+ context 'Using Puppet::Parser::Scope.new' do
+
+ describe 'Garbage inputs' do
+ inputs = [
+ [ nil ],
+ [ [ nil ] ],
+ [ { 'foo' => 'bar' } ],
+ [ { } ],
+ [ '' ],
+ [ "one", "one", "MSG to User", "4th arg" ],
+ ]
+
+ inputs.each do |input|
+ it "validate_re(#{input.inspect}) should fail" do
+ expect { subject.call [input] }.to raise_error Puppet::ParseError
+ end
+ end
+ end
+
+ describe 'Valid inputs' do
+ inputs = [
+ [ '/full/path/to/something', '^/full' ],
+ [ '/full/path/to/something', 'full' ],
+ [ '/full/path/to/something', ['full', 'absent'] ],
+ [ '/full/path/to/something', ['full', 'absent'], 'Message to the user' ],
+ ]
+
+ inputs.each do |input|
+ it "validate_re(#{input.inspect}) should not fail" do
+ expect { subject.call input }.not_to raise_error
+ end
+ end
+ end
+ describe "Valid inputs which should raise an exception without a message" do
+ # The intent here is to make sure valid inputs raise exceptions when they
+ # don't specify an error message to display. This is the behvior in
+ # 2.2.x and prior.
+ inputs = [
+ [ "hello", [ "bye", "later", "adios" ] ],
+ [ "greetings", "salutations" ],
+ ]
+
+ inputs.each do |input|
+ it "validate_re(#{input.inspect}) should fail" do
+ expect { subject.call input }.to raise_error /validate_re.*?does not match/
+ end
+ end
+ end
+ describe "Nicer Error Messages" do
+ # The intent here is to make sure the function returns the 3rd argument
+ # in the exception thrown
+ inputs = [
+ [ "hello", [ "bye", "later", "adios" ], "MSG to User" ],
+ [ "greetings", "salutations", "Error, greetings does not match salutations" ],
+ ]
+
+ inputs.each do |input|
+ it "validate_re(#{input.inspect}) should fail" do
+ expect { subject.call input }.to raise_error /#{input[2]}/
+ end
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe "the validate_slength function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("validate_slength")).to eq("function_validate_slength")
+ end
+
+ describe "validating the input argument types" do
+ it "raises an error if there are less than two arguments" do
+ expect { scope.function_validate_slength([]) }.to raise_error Puppet::ParseError, /Wrong number of arguments/
+ end
+
+ it "raises an error if there are more than three arguments" do
+ expect { scope.function_validate_slength(['input', 1, 2, 3]) }.to raise_error Puppet::ParseError, /Wrong number of arguments/
+ end
+
+ it "raises an error if the first argument is not a string" do
+ expect { scope.function_validate_slength([Object.new, 2, 1]) }.to raise_error Puppet::ParseError, /Expected first argument.*got .*Object/
+ end
+
+ it "raises an error if the second argument cannot be cast to an Integer" do
+ expect { scope.function_validate_slength(['input', Object.new]) }.to raise_error Puppet::ParseError, /Expected second argument.*got .*Object/
+ end
+
+ it "raises an error if the third argument cannot be cast to an Integer" do
+ expect { scope.function_validate_slength(['input', 1, Object.new]) }.to raise_error Puppet::ParseError, /Expected third argument.*got .*Object/
+ end
+
+ it "raises an error if the second argument is smaller than the third argument" do
+ expect { scope.function_validate_slength(['input', 1, 2]) }.to raise_error Puppet::ParseError, /Expected second argument to be larger than third argument/
+ end
+ end
+
+ describe "validating the input string length" do
+ describe "when the input is a string" do
+ it "fails validation if the string is larger than the max length" do
+ expect { scope.function_validate_slength(['input', 1]) }.to raise_error Puppet::ParseError, /Expected length .* between 0 and 1, was 5/
+ end
+
+ it "fails validation if the string is less than the min length" do
+ expect { scope.function_validate_slength(['input', 10, 6]) }.to raise_error Puppet::ParseError, /Expected length .* between 6 and 10, was 5/
+ end
+
+ it "doesn't raise an error if the string is under the max length" do
+ scope.function_validate_slength(['input', 10])
+ end
+
+ it "doesn't raise an error if the string is equal to the max length" do
+ scope.function_validate_slength(['input', 5])
+ end
+
+ it "doesn't raise an error if the string is equal to the min length" do
+ scope.function_validate_slength(['input', 10, 5])
+ end
+ end
+
+ describe "when the input is an array" do
+ it "fails validation if one of the array elements is not a string" do
+ expect { scope.function_validate_slength([["a", "b", Object.new], 2]) }.to raise_error Puppet::ParseError, /Expected element at array position 2 .*String, got .*Object/
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe Puppet::Parser::Functions.function(:validate_string) do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ describe 'when calling validate_string from puppet' do
+
+ %w{ foo bar baz }.each do |the_string|
+
+ it "should compile when #{the_string} is a string" do
+ Puppet[:code] = "validate_string('#{the_string}')"
+ scope.compiler.compile
+ end
+
+ it "should compile when #{the_string} is a bare word" do
+ Puppet[:code] = "validate_string(#{the_string})"
+ scope.compiler.compile
+ end
+
+ end
+
+ %w{ true false }.each do |the_string|
+ it "should compile when #{the_string} is a string" do
+ Puppet[:code] = "validate_string('#{the_string}')"
+ scope.compiler.compile
+ end
+
+ it "should not compile when #{the_string} is a bare word" do
+ Puppet[:code] = "validate_string(#{the_string})"
+ expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /is not a string/)
+ end
+ end
+
+ it "should compile when multiple string arguments are passed" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = ''
+ $bar = 'two'
+ validate_string($foo, $bar)
+ ENDofPUPPETcode
+ scope.compiler.compile
+ end
+
+ it "should compile when an explicitly undef variable is passed (NOTE THIS MAY NOT BE DESIRABLE)" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ $foo = undef
+ validate_string($foo)
+ ENDofPUPPETcode
+ scope.compiler.compile
+ end
+
+ it "should compile when an undefined variable is passed (NOTE THIS MAY NOT BE DESIRABLE)" do
+ Puppet[:code] = <<-'ENDofPUPPETcode'
+ validate_string($foobarbazishouldnotexist)
+ ENDofPUPPETcode
+ scope.compiler.compile
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the values_at function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("values_at")).to eq("function_values_at")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_values_at([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a ParseError if you try to use a range where stop is greater then start" do
+ expect { scope.function_values_at([['a','b'],["3-1"]]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return a value at from an array" do
+ result = scope.function_values_at([['a','b','c'],"1"])
+ expect(result).to(eq(['b']))
+ end
+
+ it "should return a value at from an array when passed a range" do
+ result = scope.function_values_at([['a','b','c'],"0-1"])
+ expect(result).to(eq(['a','b']))
+ end
+
+ it "should return chosen values from an array when passed number of indexes" do
+ result = scope.function_values_at([['a','b','c'],["0","2"]])
+ expect(result).to(eq(['a','c']))
+ end
+
+ it "should return chosen values from an array when passed ranges and multiple indexes" do
+ result = scope.function_values_at([['a','b','c','d','e','f','g'],["0","2","4-5"]])
+ expect(result).to(eq(['a','c','e','f']))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the values function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("values")).to eq("function_values")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_values([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should return values from a hash" do
+ result = scope.function_values([{'a'=>'1','b'=>'2','c'=>'3'}])
+ # =~ is the RSpec::Matchers::MatchArray matcher.
+ # A.K.A. "array with same elements" (multiset) matching
+ expect(result).to match_array(%w{ 1 2 3 })
+ end
+
+ it "should return a multiset" do
+ result = scope.function_values([{'a'=>'1','b'=>'3','c'=>'3'}])
+ expect(result).to match_array(%w{ 1 3 3 })
+ expect(result).not_to match_array(%w{ 1 3 })
+ end
+
+ it "should raise a ParseError unless a Hash is provided" do
+ expect { scope.function_values([['a','b','c']]) }.to( raise_error(Puppet::ParseError))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the zip function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_zip([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should be able to zip an array" do
+ result = scope.function_zip([['1','2','3'],['4','5','6']])
+ expect(result).to(eq([["1", "4"], ["2", "5"], ["3", "6"]]))
+ result = scope.function_zip([['1','2','3'],['4','5','6'], false])
+ result.should(eq([["1", "4"], ["2", "5"], ["3", "6"]]))
+ end
+
+ it "should be able to zip an array and flatten" do
+ result = scope.function_zip([['1','2','3'],['4','5','6'], true])
+ result.should(eq(["1", "4", "2", "5", "3", "6"]))
+ end
+
+ it "should accept objects which extend String for the second argument" do
+ class AlsoString < String
+ end
+
+ value = AlsoString.new('false')
+ result = scope.function_zip([['1','2','3'],['4','5','6'],value])
+ result.should(eq([["1", "4"], ["2", "5"], ["3", "6"]]))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+module PuppetSpec::Compiler
+ def compile_to_catalog(string, node = Puppet::Node.new('foonode'))
+ Puppet[:code] = string
+ Puppet::Parser::Compiler.compile(node)
+ end
+
+ def compile_to_ral(manifest)
+ catalog = compile_to_catalog(manifest)
+ ral = catalog.to_ral
+ ral.finalize
+ ral
+ end
+
+ def compile_to_relationship_graph(manifest, prioritizer = Puppet::Graph::SequentialPrioritizer.new)
+ ral = compile_to_ral(manifest)
+ graph = Puppet::Graph::RelationshipGraph.new(prioritizer)
+ graph.populate_from(ral)
+ graph
+ end
+
+ if Puppet.version.to_f >= 3.3
+ def apply_compiled_manifest(manifest, prioritizer = Puppet::Graph::SequentialPrioritizer.new)
+ transaction = Puppet::Transaction.new(compile_to_ral(manifest),
+ Puppet::Transaction::Report.new("apply"),
+ prioritizer)
+ transaction.evaluate
+ transaction.report.finalize_report
+
+ transaction
+ end
+ else
+ def apply_compiled_manifest(manifest)
+ transaction = Puppet::Transaction.new(compile_to_ral(manifest), Puppet::Transaction::Report.new("apply"))
+ transaction.evaluate
+ transaction.report.finalize_report
+
+ transaction
+ end
+ end
+
+ def order_resources_traversed_in(relationships)
+ order_seen = []
+ relationships.traverse { |resource| order_seen << resource.ref }
+ order_seen
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+# This just makes some nice things available at global scope, and for setup of
+# tests to use a real fake database, rather than a fake stubs-that-don't-work
+# version of the same. Fun times.
+def sqlite?
+ if $sqlite.nil?
+ begin
+ require 'sqlite3'
+ $sqlite = true
+ rescue LoadError
+ $sqlite = false
+ end
+ end
+ $sqlite
+end
+
+def can_use_scratch_database?
+ sqlite? and Puppet.features.rails?
+end
+
+
+# This is expected to be called in your `before :each` block, and will get you
+# ready to roll with a serious database and all. Cleanup is handled
+# automatically for you. Nothing to do there.
+def setup_scratch_database
+ Puppet[:dbadapter] = 'sqlite3'
+ Puppet[:dblocation] = ':memory:'
+ Puppet[:railslog] = PuppetSpec::Files.tmpfile('storeconfigs.log')
+ Puppet::Rails.init
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'fileutils'
+require 'tempfile'
+require 'tmpdir'
+require 'pathname'
+
+# A support module for testing files.
+module PuppetSpec::Files
+ def self.cleanup
+ $global_tempfiles ||= []
+ while path = $global_tempfiles.pop do
+ begin
+ Dir.unstub(:entries)
+ FileUtils.rm_rf path, :secure => true
+ rescue Errno::ENOENT
+ # nothing to do
+ end
+ end
+ end
+
+ def make_absolute(path) PuppetSpec::Files.make_absolute(path) end
+ def self.make_absolute(path)
+ path = File.expand_path(path)
+ path[0] = 'c' if Puppet.features.microsoft_windows?
+ path
+ end
+
+ def tmpfile(name, dir = nil) PuppetSpec::Files.tmpfile(name, dir) end
+ def self.tmpfile(name, dir = nil)
+ # Generate a temporary file, just for the name...
+ source = dir ? Tempfile.new(name, dir) : Tempfile.new(name)
+ path = source.path
+ source.close!
+
+ record_tmp(File.expand_path(path))
+
+ path
+ end
+
+ def file_containing(name, contents) PuppetSpec::Files.file_containing(name, contents) end
+ def self.file_containing(name, contents)
+ file = tmpfile(name)
+ File.open(file, 'wb') { |f| f.write(contents) }
+ file
+ end
+
+ def tmpdir(name) PuppetSpec::Files.tmpdir(name) end
+ def self.tmpdir(name)
+ dir = Dir.mktmpdir(name)
+
+ record_tmp(dir)
+
+ dir
+ end
+
+ def self.record_tmp(tmp)
+ # ...record it for cleanup,
+ $global_tempfiles ||= []
+ $global_tempfiles << tmp
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+module PuppetSpec::Fixtures
+ def fixtures(*rest)
+ File.join(PuppetSpec::FIXTURE_DIR, *rest)
+ end
+ def my_fixture_dir
+ callers = caller
+ while line = callers.shift do
+ next unless found = line.match(%r{/spec/(.*)_spec\.rb:})
+ return fixtures(found[1])
+ end
+ fail "sorry, I couldn't work out your path from the caller stack!"
+ end
+ def my_fixture(name)
+ file = File.join(my_fixture_dir, name)
+ unless File.readable? file then
+ fail Puppet::DevError, "fixture '#{name}' for #{my_fixture_dir} is not readable"
+ end
+ return file
+ end
+ def my_fixtures(glob = '*', flags = 0)
+ files = Dir.glob(File.join(my_fixture_dir, glob), flags)
+ unless files.length > 0 then
+ fail Puppet::DevError, "fixture '#{glob}' for #{my_fixture_dir} had no files!"
+ end
+ block_given? and files.each do |file| yield file end
+ files
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'stringio'
+
+########################################################################
+# Backward compatibility for Jenkins outdated environment.
+module RSpec
+ module Matchers
+ module BlockAliases
+ alias_method :to, :should unless method_defined? :to
+ alias_method :to_not, :should_not unless method_defined? :to_not
+ alias_method :not_to, :should_not unless method_defined? :not_to
+ end
+ end
+end
+
+
+########################################################################
+# Custom matchers...
+RSpec::Matchers.define :have_matching_element do |expected|
+ match do |actual|
+ actual.any? { |item| item =~ expected }
+ end
+end
+
+
+RSpec::Matchers.define :exit_with do |expected|
+ actual = nil
+ match do |block|
+ begin
+ block.call
+ rescue SystemExit => e
+ actual = e.status
+ end
+ actual and actual == expected
+ end
+ failure_message_for_should do |block|
+ "expected exit with code #{expected} but " +
+ (actual.nil? ? " exit was not called" : "we exited with #{actual} instead")
+ end
+ failure_message_for_should_not do |block|
+ "expected that exit would not be called with #{expected}"
+ end
+ description do
+ "expect exit with #{expected}"
+ end
+end
+
+class HavePrintedMatcher
+ attr_accessor :expected, :actual
+
+ def initialize(expected)
+ case expected
+ when String, Regexp
+ @expected = expected
+ else
+ @expected = expected.to_s
+ end
+ end
+
+ def matches?(block)
+ begin
+ $stderr = $stdout = StringIO.new
+ $stdout.set_encoding('UTF-8') if $stdout.respond_to?(:set_encoding)
+ block.call
+ $stdout.rewind
+ @actual = $stdout.read
+ ensure
+ $stdout = STDOUT
+ $stderr = STDERR
+ end
+
+ if @actual then
+ case @expected
+ when String
+ @actual.include? @expected
+ when Regexp
+ @expected.match @actual
+ end
+ else
+ false
+ end
+ end
+
+ def failure_message_for_should
+ if @actual.nil? then
+ "expected #{@expected.inspect}, but nothing was printed"
+ else
+ "expected #{@expected.inspect} to be printed; got:\n#{@actual}"
+ end
+ end
+
+ def failure_message_for_should_not
+ "expected #{@expected.inspect} to not be printed; got:\n#{@actual}"
+ end
+
+ def description
+ "expect #{@expected.inspect} to be printed"
+ end
+end
+
+def have_printed(what)
+ HavePrintedMatcher.new(what)
+end
+
+RSpec::Matchers.define :equal_attributes_of do |expected|
+ match do |actual|
+ actual.instance_variables.all? do |attr|
+ actual.instance_variable_get(attr) == expected.instance_variable_get(attr)
+ end
+ end
+end
+
+RSpec::Matchers.define :be_one_of do |*expected|
+ match do |actual|
+ expected.include? actual
+ end
+
+ failure_message_for_should do |actual|
+ "expected #{actual.inspect} to be one of #{expected.map(&:inspect).join(' or ')}"
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+module PuppetSpec::Modules
+ class << self
+ def create(name, dir, options = {})
+ module_dir = File.join(dir, name)
+ FileUtils.mkdir_p(module_dir)
+
+ environment = options[:environment]
+
+ if metadata = options[:metadata]
+ metadata[:source] ||= 'github'
+ metadata[:author] ||= 'puppetlabs'
+ metadata[:version] ||= '9.9.9'
+ metadata[:license] ||= 'to kill'
+ metadata[:dependencies] ||= []
+
+ metadata[:name] = "#{metadata[:author]}/#{name}"
+
+ File.open(File.join(module_dir, 'metadata.json'), 'w') do |f|
+ f.write(metadata.to_pson)
+ end
+ end
+
+ Puppet::Module.new(name, module_dir, environment)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+module PuppetSpec::Pops
+ extend RSpec::Matchers::DSL
+
+ # Checks if an Acceptor has a specific issue in its list of diagnostics
+ matcher :have_issue do |expected|
+ match do |actual|
+ actual.diagnostics.index { |i| i.issue == expected } != nil
+ end
+ failure_message_for_should do |actual|
+ "expected Acceptor[#{actual.diagnostics.collect { |i| i.issue.issue_code }.join(',')}] to contain issue #{expected.issue_code}"
+ end
+ failure_message_for_should_not do |actual|
+ "expected Acceptor[#{actual.diagnostics.collect { |i| i.issue.issue_code }.join(',')}] to not contain issue #{expected.issue_code}"
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+module PuppetSpec::Scope
+ # Initialize a new scope suitable for testing.
+ #
+ def create_test_scope_for_node(node_name)
+ node = Puppet::Node.new(node_name)
+ compiler = Puppet::Parser::Compiler.new(node)
+ scope = Puppet::Parser::Scope.new(compiler)
+ scope.source = Puppet::Resource::Type.new(:node, node_name)
+ scope.parent = compiler.topscope
+ scope
+ end
+
+end
\ No newline at end of file
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+module PuppetSpec::Settings
+
+ # It would probably be preferable to refactor defaults.rb such that the real definitions of
+ # these settings were available as a variable, which was then accessible for use during tests.
+ # However, I'm not doing that yet because I don't want to introduce any additional moving parts
+ # to this already very large changeset.
+ # Would be nice to clean this up later. --cprice 2012-03-20
+ TEST_APP_DEFAULT_DEFINITIONS = {
+ :name => { :default => "test", :desc => "name" },
+ :logdir => { :type => :directory, :default => "test", :desc => "logdir" },
+ :confdir => { :type => :directory, :default => "test", :desc => "confdir" },
+ :vardir => { :type => :directory, :default => "test", :desc => "vardir" },
+ :rundir => { :type => :directory, :default => "test", :desc => "rundir" },
+ }
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+# Support code for running stuff with warnings disabled.
+module Kernel
+ def with_verbose_disabled
+ verbose, $VERBOSE = $VERBOSE, nil
+ result = yield
+ $VERBOSE = verbose
+ return result
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'rspec'
+
+class Object
+ # This is necessary because the RAL has a 'should'
+ # method.
+ alias :must :should
+ alias :must_not :should_not
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+# Some monkey-patching to allow us to test private methods.
+class Class
+ def publicize_methods(*methods)
+ saved_private_instance_methods = methods.empty? ? self.private_instance_methods : methods
+
+ self.class_eval { public(*saved_private_instance_methods) }
+ yield
+ self.class_eval { private(*saved_private_instance_methods) }
+ end
+end
--- /dev/null
+--format
+s
+--colour
+--loadby
+mtime
+--backtrace
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+dir = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.unshift File.join(dir, 'lib')
+
+# So everyone else doesn't have to include this base constant.
+module PuppetSpec
+ FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
+end
+
+require 'puppet'
+require 'rspec-puppet'
+require 'puppetlabs_spec_helper/module_spec_helper'
+require 'puppet_spec/verbose'
+require 'puppet_spec/files'
+require 'puppet_spec/settings'
+require 'puppet_spec/fixtures'
+require 'puppet_spec/matchers'
+require 'puppet_spec/database'
+require 'monkey_patches/alias_should_to_must'
+require 'mocha/setup'
+
+
+
+RSpec.configure do |config|
+ config.before :each do
+ # Ensure that we don't accidentally cache facts and environment between
+ # test cases. This requires each example group to explicitly load the
+ # facts being exercised with something like
+ # Facter.collection.loader.load(:ipaddress)
+ Facter::Util::Loader.any_instance.stubs(:load_all)
+ Facter.clear
+ Facter.clear_messages
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'beaker-rspec'
+
+UNSUPPORTED_PLATFORMS = []
+
+unless ENV['RS_PROVISION'] == 'no' or ENV['BEAKER_provision'] == 'no'
+ foss_opts = {
+ :default_action => 'gem_install',
+ :version => (ENV['PUPPET_VERSION'] ? ENV['PUPPET_VERSION'] : '3.7.2'),
+ }
+
+ if default.is_pe?; then install_pe; else install_puppet( foss_opts ); end
+
+ hosts.each do |host|
+ if host['platform'] !~ /windows/i
+ if host.is_pe?
+ on host, 'mkdir -p /etc/puppetlabs/facter/facts.d'
+ else
+ on host, "/bin/touch #{host['puppetpath']}/hiera.yaml"
+ on host, "mkdir -p #{host['distmoduledir']}"
+ on host, 'mkdir -p /etc/facter/facts.d'
+ end
+ end
+ end
+end
+
+RSpec.configure do |c|
+ # Project root
+ proj_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+ # Readable test descriptions
+ c.formatter = :documentation
+
+ # Configure all nodes in nodeset
+ c.before :suite do
+ if ENV['FUTURE_PARSER'] == 'true'
+ default[:default_apply_opts] ||= {}
+ default[:default_apply_opts].merge!({:parser => 'future'})
+ end
+
+ copy_root_module_to(default, :source => proj_root, :module_name => 'stdlib')
+ end
+end
+
+def is_future_parser_enabled?
+ if default[:default_apply_opts]
+ return default[:default_apply_opts][:parser] == 'future'
+ end
+ return false
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'facter/facter_dot_d'
+
+describe Facter::Util::DotD do
+
+ context 'returns a simple fact' do
+ before :each do
+ Facter.stubs(:version).returns('1.6.1')
+ subject.stubs(:entries).returns(['/etc/facter/facts.d/fake_fact.txt'])
+ File.stubs(:readlines).with('/etc/facter/facts.d/fake_fact.txt').returns(['fake_fact=fake fact'])
+ subject.create
+ end
+
+ it 'should return successfully' do
+ expect(Facter.fact(:fake_fact).value).to eq('fake fact')
+ end
+ end
+
+ context 'returns a fact with equals signs' do
+ before :each do
+ Facter.stubs(:version).returns('1.6.1')
+ subject.stubs(:entries).returns(['/etc/facter/facts.d/foo.txt'])
+ File.stubs(:readlines).with('/etc/facter/facts.d/foo.txt').returns(['foo=1+1=2'])
+ subject.create
+ end
+
+ it 'should return successfully' do
+ expect(Facter.fact(:foo).value).to eq('1+1=2')
+ end
+ end
+end
--- /dev/null
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+describe "PE Version specs" do
+ before :each do
+ # Explicitly load the pe_version.rb file which contains generated facts
+ # that cannot be automatically loaded. Puppet 2.x implements
+ # Facter.collection.load while Facter 1.x markes Facter.collection.load as
+ # a private method.
+ if Facter.collection.respond_to? :load
+ Facter.collection.load(:pe_version)
+ else
+ Facter.collection.loader.load(:pe_version)
+ end
+ end
+
+ context "If PE is installed" do
+ %w{ 2.6.1 2.10.300 }.each do |version|
+ puppetversion = "2.7.19 (Puppet Enterprise #{version})"
+ context "puppetversion => #{puppetversion}" do
+ before :each do
+ Facter.fact(:puppetversion).stubs(:value).returns(puppetversion)
+ end
+
+ (major,minor,patch) = version.split(".")
+
+ it "Should return true" do
+ expect(Facter.fact(:is_pe).value).to eq(true)
+ end
+
+ it "Should have a version of #{version}" do
+ expect(Facter.fact(:pe_version).value).to eq(version)
+ end
+
+ it "Should have a major version of #{major}" do
+ expect(Facter.fact(:pe_major_version).value).to eq(major)
+ end
+
+ it "Should have a minor version of #{minor}" do
+ expect(Facter.fact(:pe_minor_version).value).to eq(minor)
+ end
+
+ it "Should have a patch version of #{patch}" do
+ expect(Facter.fact(:pe_patch_version).value).to eq(patch)
+ end
+ end
+ end
+ end
+
+ context "When PE is not installed" do
+ before :each do
+ Facter.fact(:puppetversion).stubs(:value).returns("2.7.19")
+ end
+
+ it "is_pe is false" do
+ expect(Facter.fact(:is_pe).value).to eq(false)
+ end
+
+ it "pe_version is nil" do
+ expect(Facter.fact(:pe_version).value).to be_nil
+ end
+
+ it "pe_major_version is nil" do
+ expect(Facter.fact(:pe_major_version).value).to be_nil
+ end
+
+ it "pe_minor_version is nil" do
+ expect(Facter.fact(:pe_minor_version).value).to be_nil
+ end
+
+ it "Should have a patch version" do
+ expect(Facter.fact(:pe_patch_version).value).to be_nil
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'facter/root_home'
+
+describe Facter::Util::RootHome do
+ context "solaris" do
+ let(:root_ent) { "root:x:0:0:Super-User:/:/sbin/sh" }
+ let(:expected_root_home) { "/" }
+
+ it "should return /" do
+ Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
+ expect(Facter::Util::RootHome.get_root_home).to eq(expected_root_home)
+ end
+ end
+ context "linux" do
+ let(:root_ent) { "root:x:0:0:root:/root:/bin/bash" }
+ let(:expected_root_home) { "/root" }
+
+ it "should return /root" do
+ Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
+ expect(Facter::Util::RootHome.get_root_home).to eq(expected_root_home)
+ end
+ end
+ context "windows" do
+ before :each do
+ Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(nil)
+ end
+ it "should be nil on windows" do
+ expect(Facter::Util::RootHome.get_root_home).to be_nil
+ end
+ end
+end
+
+describe 'root_home', :type => :fact do
+ before { Facter.clear }
+ after { Facter.clear }
+
+ context "macosx" do
+ before do
+ Facter.fact(:kernel).stubs(:value).returns("Darwin")
+ Facter.fact(:osfamily).stubs(:value).returns("Darwin")
+ end
+ let(:expected_root_home) { "/var/root" }
+ sample_dscacheutil = File.read(fixtures('dscacheutil','root'))
+
+ it "should return /var/root" do
+ Facter::Util::Resolution.stubs(:exec).with("dscacheutil -q user -a name root").returns(sample_dscacheutil)
+ expect(Facter.fact(:root_home).value).to eq(expected_root_home)
+ end
+ end
+
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'facter/util/puppet_settings'
+
+describe Facter::Util::PuppetSettings do
+
+ describe "#with_puppet" do
+ context "Without Puppet loaded" do
+ before(:each) do
+ Module.expects(:const_get).with("Puppet").raises(NameError)
+ end
+
+ it 'should be nil' do
+ expect(subject.with_puppet { Puppet[:vardir] }).to be_nil
+ end
+ it 'should not yield to the block' do
+ Puppet.expects(:[]).never
+ expect(subject.with_puppet { Puppet[:vardir] }).to be_nil
+ end
+ end
+ context "With Puppet loaded" do
+ module Puppet; end
+ let(:vardir) { "/var/lib/puppet" }
+
+ before :each do
+ Puppet.expects(:[]).with(:vardir).returns vardir
+ end
+ it 'should yield to the block' do
+ subject.with_puppet { Puppet[:vardir] }
+ end
+ it 'should return the nodes vardir' do
+ expect(subject.with_puppet { Puppet[:vardir] }).to eq vardir
+ end
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+if ENV["FUTURE_PARSER"] == 'yes' or Puppet.version >= "4"
+ require 'puppet/pops'
+ require 'puppet/loaders'
+
+ describe 'the type_of function' do
+ before(:all) do
+ loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [File.join(fixtures, "modules")]))
+ Puppet.push_context({:loaders => loaders}, "test-examples")
+ end
+
+ after(:all) do
+ Puppet::Pops::Loaders.clear
+ Puppet::pop_context()
+ end
+
+ let(:func) do
+ # Load the function from the environment modulepath's modules (ie, fixtures)
+ Puppet.lookup(:loaders).private_environment_loader.load(:function, 'type_of')
+ end
+
+ it 'gives the type of a string' do
+ expect(func.call({}, 'hello world')).to be_kind_of(Puppet::Pops::Types::PStringType)
+ end
+
+ it 'gives the type of an integer' do
+ expect(func.call({}, 5)).to be_kind_of(Puppet::Pops::Types::PIntegerType)
+ end
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the basename function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ Puppet::Parser::Functions.function("basename").should == "function_basename"
+ end
+
+ it "should raise a ParseError if there is less than 1 argument" do
+ lambda { scope.function_basename([]) }.should( raise_error(Puppet::ParseError))
+ end
+
+ it "should raise a ParseError if there are more than 2 arguments" do
+ lambda { scope.function_basename(['a', 'b', 'c']) }.should( raise_error(Puppet::ParseError))
+ end
+
+ it "should return basename for an absolute path" do
+ result = scope.function_basename(['/path/to/a/file.ext'])
+ result.should(eq('file.ext'))
+ end
+
+ it "should return basename for a relative path" do
+ result = scope.function_basename(['path/to/a/file.ext'])
+ result.should(eq('file.ext'))
+ end
+
+ it "should strip extention when extension specified (absolute path)" do
+ result = scope.function_basename(['/path/to/a/file.ext', '.ext'])
+ result.should(eq('file'))
+ end
+
+ it "should strip extention when extension specified (relative path)" do
+ result = scope.function_basename(['path/to/a/file.ext', '.ext'])
+ result.should(eq('file'))
+ end
+
+ it "should complain about non-string first argument" do
+ lambda { scope.function_basename([[]]) }.should( raise_error(Puppet::ParseError))
+ end
+
+ it "should complain about non-string second argument" do
+ lambda { scope.function_basename(['/path/to/a/file.ext', []]) }.should( raise_error(Puppet::ParseError))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the bool2str function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("bool2str")).to eq("function_bool2str")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_bool2str([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should convert true to 'true'" do
+ result = scope.function_bool2str([true])
+ expect(result).to(eq('true'))
+ end
+
+ it "should convert true to a string" do
+ result = scope.function_bool2str([true])
+ expect(result.class).to(eq(String))
+ end
+
+ it "should convert false to 'false'" do
+ result = scope.function_bool2str([false])
+ expect(result).to(eq('false'))
+ end
+
+ it "should convert false to a string" do
+ result = scope.function_bool2str([false])
+ expect(result.class).to(eq(String))
+ end
+
+ it "should not accept a string" do
+ expect { scope.function_bool2str(["false"]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should not accept a nil value" do
+ expect { scope.function_bool2str([nil]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should not accept an undef" do
+ expect { scope.function_bool2str([:undef]) }.to( raise_error(Puppet::ParseError))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+
+describe "the camelcase function" do
+ let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+
+ it "should exist" do
+ expect(Puppet::Parser::Functions.function("camelcase")).to eq("function_camelcase")
+ end
+
+ it "should raise a ParseError if there is less than 1 arguments" do
+ expect { scope.function_camelcase([]) }.to( raise_error(Puppet::ParseError))
+ end
+
+ it "should capitalize the beginning of a normal string" do
+ result = scope.function_camelcase(["abc"])
+ expect(result).to(eq("Abc"))
+ end
+
+ it "should camelcase an underscore-delimited string" do
+ result = scope.function_camelcase(["aa_bb_cc"])
+ expect(result).to(eq("AaBbCc"))
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'tempfile'
+provider_class = Puppet::Type.type(:file_line).provider(:ruby)
+describe provider_class do
+ context "when adding" do
+ let :tmpfile do
+ tmp = Tempfile.new('tmp')
+ path = tmp.path
+ tmp.close!
+ path
+ end
+ let :resource do
+ Puppet::Type::File_line.new(
+ {:name => 'foo', :path => tmpfile, :line => 'foo'}
+ )
+ end
+ let :provider do
+ provider_class.new(resource)
+ end
+
+ it 'should detect if the line exists in the file' do
+ File.open(tmpfile, 'w') do |fh|
+ fh.write('foo')
+ end
+ expect(provider.exists?).to be_truthy
+ end
+ it 'should detect if the line does not exist in the file' do
+ File.open(tmpfile, 'w') do |fh|
+ fh.write('foo1')
+ end
+ expect(provider.exists?).to be_nil
+ end
+ it 'should append to an existing file when creating' do
+ provider.create
+ expect(File.read(tmpfile).chomp).to eq('foo')
+ end
+ end
+
+ context "when matching" do
+ before :each do
+ # TODO: these should be ported over to use the PuppetLabs spec_helper
+ # file fixtures once the following pull request has been merged:
+ # https://github.com/puppetlabs/puppetlabs-stdlib/pull/73/files
+ tmp = Tempfile.new('tmp')
+ @tmpfile = tmp.path
+ tmp.close!
+ @resource = Puppet::Type::File_line.new(
+ {
+ :name => 'foo',
+ :path => @tmpfile,
+ :line => 'foo = bar',
+ :match => '^foo\s*=.*$',
+ }
+ )
+ @provider = provider_class.new(@resource)
+ end
+
+ describe 'using match' do
+ it 'should raise an error if more than one line matches, and should not have modified the file' do
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write("foo1\nfoo=blah\nfoo2\nfoo=baz")
+ end
+ expect(@provider.exists?).to be_nil
+ expect { @provider.create }.to raise_error(Puppet::Error, /More than one line.*matches/)
+ expect(File.read(@tmpfile)).to eql("foo1\nfoo=blah\nfoo2\nfoo=baz")
+ end
+
+ it 'should replace all lines that matches' do
+ @resource = Puppet::Type::File_line.new(
+ {
+ :name => 'foo',
+ :path => @tmpfile,
+ :line => 'foo = bar',
+ :match => '^foo\s*=.*$',
+ :multiple => true,
+ }
+ )
+ @provider = provider_class.new(@resource)
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write("foo1\nfoo=blah\nfoo2\nfoo=baz")
+ end
+ expect(@provider.exists?).to be_nil
+ @provider.create
+ expect(File.read(@tmpfile).chomp).to eql("foo1\nfoo = bar\nfoo2\nfoo = bar")
+ end
+
+ it 'should raise an error with invalid values' do
+ expect {
+ @resource = Puppet::Type::File_line.new(
+ {
+ :name => 'foo',
+ :path => @tmpfile,
+ :line => 'foo = bar',
+ :match => '^foo\s*=.*$',
+ :multiple => 'asgadga',
+ }
+ )
+ }.to raise_error(Puppet::Error, /Invalid value "asgadga"\. Valid values are true, false\./)
+ end
+
+ it 'should replace a line that matches' do
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write("foo1\nfoo=blah\nfoo2")
+ end
+ expect(@provider.exists?).to be_nil
+ @provider.create
+ expect(File.read(@tmpfile).chomp).to eql("foo1\nfoo = bar\nfoo2")
+ end
+ it 'should add a new line if no lines match' do
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write("foo1\nfoo2")
+ end
+ expect(@provider.exists?).to be_nil
+ @provider.create
+ expect(File.read(@tmpfile)).to eql("foo1\nfoo2\nfoo = bar\n")
+ end
+ it 'should do nothing if the exact line already exists' do
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write("foo1\nfoo = bar\nfoo2")
+ end
+ expect(@provider.exists?).to be_truthy
+ @provider.create
+ expect(File.read(@tmpfile).chomp).to eql("foo1\nfoo = bar\nfoo2")
+ end
+ end
+
+ describe 'using after' do
+ let :resource do
+ Puppet::Type::File_line.new(
+ {
+ :name => 'foo',
+ :path => @tmpfile,
+ :line => 'inserted = line',
+ :after => '^foo1',
+ }
+ )
+ end
+
+ let :provider do
+ provider_class.new(resource)
+ end
+ context 'match and after set' do
+ shared_context 'resource_create' do
+ let(:match) { '^foo2$' }
+ let(:after) { '^foo1$' }
+ let(:resource) {
+ Puppet::Type::File_line.new(
+ {
+ :name => 'foo',
+ :path => @tmpfile,
+ :line => 'inserted = line',
+ :after => after,
+ :match => match,
+ }
+ )
+ }
+ end
+ before :each do
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write("foo1\nfoo2\nfoo = baz")
+ end
+ end
+ describe 'inserts at match' do
+ include_context 'resource_create'
+ it {
+ provider.create
+ expect(File.read(@tmpfile).chomp).to eq("foo1\ninserted = line\nfoo = baz")
+ }
+ end
+ describe 'inserts a new line after when no match' do
+ include_context 'resource_create' do
+ let(:match) { '^nevergoingtomatch$' }
+ end
+ it {
+ provider.create
+ expect(File.read(@tmpfile).chomp).to eq("foo1\ninserted = line\nfoo2\nfoo = baz")
+ }
+ end
+ describe 'append to end of file if no match for both after and match' do
+ include_context 'resource_create' do
+ let(:match) { '^nevergoingtomatch$' }
+ let(:after) { '^stillneverafter' }
+ end
+ it {
+ provider.create
+ expect(File.read(@tmpfile).chomp).to eq("foo1\nfoo2\nfoo = baz\ninserted = line")
+ }
+ end
+ end
+ context 'with one line matching the after expression' do
+ before :each do
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write("foo1\nfoo = blah\nfoo2\nfoo = baz")
+ end
+ end
+
+ it 'inserts the specified line after the line matching the "after" expression' do
+ provider.create
+ expect(File.read(@tmpfile).chomp).to eql("foo1\ninserted = line\nfoo = blah\nfoo2\nfoo = baz")
+ end
+ end
+
+ context 'with two lines matching the after expression' do
+ before :each do
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write("foo1\nfoo = blah\nfoo2\nfoo1\nfoo = baz")
+ end
+ end
+
+ it 'errors out stating "One or no line must match the pattern"' do
+ expect { provider.create }.to raise_error(Puppet::Error, /One or no line must match the pattern/)
+ end
+ end
+
+ context 'with no lines matching the after expression' do
+ let :content do
+ "foo3\nfoo = blah\nfoo2\nfoo = baz\n"
+ end
+
+ before :each do
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write(content)
+ end
+ end
+
+ it 'appends the specified line to the file' do
+ provider.create
+ expect(File.read(@tmpfile)).to eq(content << resource[:line] << "\n")
+ end
+ end
+ end
+ end
+
+ context "when removing" do
+ before :each do
+ # TODO: these should be ported over to use the PuppetLabs spec_helper
+ # file fixtures once the following pull request has been merged:
+ # https://github.com/puppetlabs/puppetlabs-stdlib/pull/73/files
+ tmp = Tempfile.new('tmp')
+ @tmpfile = tmp.path
+ tmp.close!
+ @resource = Puppet::Type::File_line.new(
+ {
+ :name => 'foo',
+ :path => @tmpfile,
+ :line => 'foo',
+ :ensure => 'absent',
+ }
+ )
+ @provider = provider_class.new(@resource)
+ end
+ it 'should remove the line if it exists' do
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write("foo1\nfoo\nfoo2")
+ end
+ @provider.destroy
+ expect(File.read(@tmpfile)).to eql("foo1\nfoo2")
+ end
+
+ it 'should remove the line without touching the last new line' do
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write("foo1\nfoo\nfoo2\n")
+ end
+ @provider.destroy
+ expect(File.read(@tmpfile)).to eql("foo1\nfoo2\n")
+ end
+
+ it 'should remove any occurence of the line' do
+ File.open(@tmpfile, 'w') do |fh|
+ fh.write("foo1\nfoo\nfoo2\nfoo\nfoo")
+ end
+ @provider.destroy
+ expect(File.read(@tmpfile)).to eql("foo1\nfoo2\n")
+ end
+ end
+end
--- /dev/null
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+anchor = Puppet::Type.type(:anchor).new(:name => "ntp::begin")
+
+describe anchor do
+ it "should stringify normally" do
+ expect(anchor.to_s).to eq("Anchor[ntp::begin]")
+ end
+end
--- /dev/null
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'tempfile'
+describe Puppet::Type.type(:file_line) do
+ let :file_line do
+ Puppet::Type.type(:file_line).new(:name => 'foo', :line => 'line', :path => '/tmp/path')
+ end
+ it 'should accept a line and path' do
+ file_line[:line] = 'my_line'
+ expect(file_line[:line]).to eq('my_line')
+ file_line[:path] = '/my/path'
+ expect(file_line[:path]).to eq('/my/path')
+ end
+ it 'should accept a match regex' do
+ file_line[:match] = '^foo.*$'
+ expect(file_line[:match]).to eq('^foo.*$')
+ end
+ it 'should accept a match regex that does not match the specified line' do
+ expect {
+ Puppet::Type.type(:file_line).new(
+ :name => 'foo',
+ :path => '/my/path',
+ :line => 'foo=bar',
+ :match => '^bar=blah$'
+ )}.not_to raise_error
+ end
+ it 'should accept a match regex that does match the specified line' do
+ expect {
+ Puppet::Type.type(:file_line).new(
+ :name => 'foo',
+ :path => '/my/path',
+ :line => 'foo=bar',
+ :match => '^\s*foo=.*$'
+ )}.not_to raise_error
+ end
+ it 'should accept posix filenames' do
+ file_line[:path] = '/tmp/path'
+ expect(file_line[:path]).to eq('/tmp/path')
+ end
+ it 'should not accept unqualified path' do
+ expect { file_line[:path] = 'file' }.to raise_error(Puppet::Error, /File paths must be fully qualified/)
+ end
+ it 'should require that a line is specified' do
+ expect { Puppet::Type.type(:file_line).new(:name => 'foo', :path => '/tmp/file') }.to raise_error(Puppet::Error, /Both line and path are required attributes/)
+ end
+ it 'should require that a file is specified' do
+ expect { Puppet::Type.type(:file_line).new(:name => 'foo', :line => 'path') }.to raise_error(Puppet::Error, /Both line and path are required attributes/)
+ end
+ it 'should default to ensure => present' do
+ expect(file_line[:ensure]).to eq :present
+ end
+
+ it "should autorequire the file it manages" do
+ catalog = Puppet::Resource::Catalog.new
+ file = Puppet::Type.type(:file).new(:name => "/tmp/path")
+ catalog.add_resource file
+ catalog.add_resource file_line
+
+ relationship = file_line.autorequire.find do |rel|
+ (rel.source.to_s == "File[/tmp/path]") and (rel.target.to_s == file_line.to_s)
+ end
+ expect(relationship).to be_a Puppet::Relationship
+ end
+
+ it "should not autorequire the file it manages if it is not managed" do
+ catalog = Puppet::Resource::Catalog.new
+ catalog.add_resource file_line
+ expect(file_line.autorequire).to be_empty
+ end
+end
--- /dev/null
+# This is a simple smoke test
+# of the file_line resource type.
+file { '/tmp/dansfile':
+ ensure => present
+}->
+file_line { 'dans_line':
+ line => 'dan is awesome',
+ path => '/tmp/dansfile',
+}
--- /dev/null
+include stdlib
+info('has_interface_with(\'lo\'):', has_interface_with('lo'))
+info('has_interface_with(\'loX\'):', has_interface_with('loX'))
+info('has_interface_with(\'ipaddress\', \'127.0.0.1\'):', has_interface_with('ipaddress', '127.0.0.1'))
+info('has_interface_with(\'ipaddress\', \'127.0.0.100\'):', has_interface_with('ipaddress', '127.0.0.100'))
+info('has_interface_with(\'network\', \'127.0.0.0\'):', has_interface_with('network', '127.0.0.0'))
+info('has_interface_with(\'network\', \'128.0.0.0\'):', has_interface_with('network', '128.0.0.0'))
+info('has_interface_with(\'netmask\', \'255.0.0.0\'):', has_interface_with('netmask', '255.0.0.0'))
+info('has_interface_with(\'netmask\', \'256.0.0.0\'):', has_interface_with('netmask', '256.0.0.0'))
+
--- /dev/null
+include stdlib
+info('has_ip_address(\'192.168.1.256\'):', has_ip_address('192.168.1.256'))
+info('has_ip_address(\'127.0.0.1\'):', has_ip_address('127.0.0.1'))
--- /dev/null
+include stdlib
+info('has_ip_network(\'127.0.0.0\'):', has_ip_network('127.0.0.0'))
+info('has_ip_network(\'128.0.0.0\'):', has_ip_network('128.0.0.0'))
+
--- /dev/null
+include stdlib
+++ /dev/null
-2011-12-30 Puppet Labs <support@puppetlabs.com> - 2.2.1
-* Documentation only release for the Forge
-
-2011-12-30 Puppet Labs <support@puppetlabs.com> - 2.1.2
-* Documentation only release for PE 2.0.x
-
-2011-11-08 Puppet Labs <support@puppetlabs.com> - 2.2.0
-* #10285 - Refactor json to use pson instead.
-* Maint - Add watchr autotest script
-* Maint - Make rspec tests work with Puppet 2.6.4
-* #9859 - Add root_home fact and tests
-
-2011-08-18 Puppet Labs <support@puppetlabs.com> - 2.1.1
-* Change facts.d paths to match Facter 2.0 paths.
-* /etc/facter/facts.d
-* /etc/puppetlabs/facter/facts.d
-
-2011-08-17 Puppet Labs <support@puppetlabs.com> - 2.1.0
-* Add R.I. Pienaar's facts.d custom facter fact
-* facts defined in /etc/facts.d and /etc/puppetlabs/facts.d are
- automatically loaded now.
-
-2011-08-04 Puppet Labs <support@puppetlabs.com> - 2.0.0
-* Rename whole_line to file_line
-* This is an API change and as such motivating a 2.0.0 release according to semver.org.
-
-2011-08-04 Puppet Labs <support@puppetlabs.com> - 1.1.0
-* Rename append_line to whole_line
-* This is an API change and as such motivating a 1.1.0 release.
-
-2011-08-04 Puppet Labs <support@puppetlabs.com> - 1.0.0
-* Initial stable release
-* Add validate_array and validate_string functions
-* Make merge() function work with Ruby 1.8.5
-* Add hash merging function
-* Add has_key function
-* Add loadyaml() function
-* Add append_line native
-
-2011-06-21 Jeff McCune <jeff@puppetlabs.com> - 0.1.7
-* Add validate_hash() and getvar() functions
-
-2011-06-15 Jeff McCune <jeff@puppetlabs.com> - 0.1.6
-* Add anchor resource type to provide containment for composite classes
-
-2011-06-03 Jeff McCune <jeff@puppetlabs.com> - 0.1.5
-* Add validate_bool() function to stdlib
-
-0.1.4 2011-05-26 Jeff McCune <jeff@puppetlabs.com>
-* Move most stages after main
-
-0.1.3 2011-05-25 Jeff McCune <jeff@puppetlabs.com>
-* Add validate_re() function
-
-0.1.2 2011-05-24 Jeff McCune <jeff@puppetlabs.com>
-* Update to add annotated tag
-
-0.1.1 2011-05-24 Jeff McCune <jeff@puppetlabs.com>
-* Add stdlib::stages class with a standard set of stages
+++ /dev/null
-Copyright (C) 2011 Puppet Labs Inc
-
-and some parts:
-
-Copyright (C) 2011 Krzysztof Wilczynski
-
-Puppet Labs can be contacted at: info@puppetlabs.com
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+++ /dev/null
-name 'puppetlabs-stdlib'
-version '2.2.1'
-source 'git://github.com/puppetlabs/puppetlabs-stdlib'
-author 'puppetlabs'
-license 'Apache 2.0'
-summary 'Puppet Module Standard Library'
-description 'Standard Library for Puppet Modules'
-project_page 'https://github.com/puppetlabs/puppetlabs-stdlib'
-
-## Add dependencies, if any:
-# dependency 'username/name', '>= 1.2.0'
+++ /dev/null
-# Puppet Labs Standard Library #
-
-This module provides a "standard library" of resources for developing Puppet
-Modules. This modules will include the following additions to Puppet
-
- * Stages
- * Facts
- * Functions
- * Defined resource types
- * Types
- * Providers
-
-This module is officially curated and provided by Puppet Labs. The modules
-Puppet Labs writes and distributes will make heavy use of this standard
-library.
-
-# Versions #
-
-This module follows semver.org (v1.0.0) versioning guidelines. The standard
-library module is released as part of [Puppet
-Enterprise](http://puppetlabs.com/puppet/puppet-enterprise/) and as a result
-older versions of Puppet Enterprise that Puppet Labs still supports will have
-bugfix maintenance branches periodically "merged up" into master. The current
-list of integration branches are:
-
- * v2.1.x (v2.1.1 released in PE 1.2, 1.2.1, 1.2.3, 1.2.4)
- * v2.2.x (Never released as part of PE, only to the Forge)
- * v2.3.x (Scheduled for next PE feature release)
- * master (mainline development branch)
-
-The first Puppet Enterprise version including the stdlib module is Puppet
-Enterprise 1.2.
-
-# Compatibility #
-
-## stdlib v2.1.x, v2.2.x ##
-
-v2.1.x and v2.2.x of this module are designed to work with Puppet versions
-2.6.x and 2.7.x. There are currently no plans for a Puppet 0.25 standard
-library module.
-
-## stdlib v2.3.x ##
-
-While not yet released, the standard library may only work with Puppet 2.7.x.
-
-# Functions #
-
- Please see `puppet doc -r function` for documentation on each function. The
- current list of functions is:
-
- * getvar
- * has\_key
- * loadyaml
- * merge.rb
- * validate\_array
- * validate\_bool
- * validate\_hash
- * validate\_re
- * validate\_string
-
-## validate\_hash ##
-
- $somehash = { 'one' => 'two' }
- validate\_hash($somehash)
-
-## getvar() ##
-
-This function aims to look up variables in user-defined namespaces within
-puppet. Note, if the namespace is a class, it should already be evaluated
-before the function is used.
-
- $namespace = 'site::data'
- include "${namespace}"
- $myvar = getvar("${namespace}::myvar")
-
-## Facts ##
-
-Facts in `/etc/facter/facts.d` and `/etc/puppetlabs/facter/facts.d` are now loaded
-automatically. This is a direct copy of R.I. Pienaar's custom facter fact
-located at:
-[https://github.com/ripienaar/facter-facts/tree/master/facts-dot-d](https://github.com/ripienaar/facter-facts/tree/master/facts-dot-d)
-
+++ /dev/null
-# Releasing this module #
-
- * Work in a topic branch
- * Submit a github pull request
- * Address any comments / feeback
- * Merge into master using --no-ff
- * Update the CHANGELOG
- * Update the Modulefile
- * Create an annotated tag with git tag -a X.Y.Z -m 'version X.Y.Z'
- * Push the tag with git push origin --tags
- * Build a new package with puppet-module
- * Publish the new package to the forge
-
+++ /dev/null
-require 'rake'
-require 'rspec/core/rake_task'
-
-task :default => [:test]
-
-desc 'Run RSpec'
-RSpec::Core::RakeTask.new(:test) do |t|
- t.pattern = 'spec/{unit}/**/*.rb'
- t.rspec_opts = ['--color']
-end
-
-desc 'Generate code coverage'
-RSpec::Core::RakeTask.new(:coverage) do |t|
- t.rcov = true
- t.rcov_opts = ['--exclude', 'spec']
-end
+++ /dev/null
-# A Facter plugin that loads facts from /etc/facts.d.
-#
-# Facts can be in the form of JSON, YAML or Text files
-# and any executable that returns key=value pairs.
-#
-# In the case of scripts you can also create a file that
-# contains a cache TTL. For foo.sh store the ttl as just
-# a number in foo.sh.ttl
-#
-# The cache is stored in /tmp/facts_cache.yaml as a mode
-# 600 file and will have the end result of not calling your
-# fact scripts more often than is needed
-class Facter::Util::DotD
- require 'yaml'
-
- def initialize(dir="/etc/facts.d", cache_file="/tmp/facts_cache.yml")
- @dir = dir
- @cache_file = cache_file
- @cache = nil
- @types = {".txt" => :txt, ".json" => :json, ".yaml" => :yaml}
- end
-
- def entries
- Dir.entries(@dir).reject{|f| f =~ /^\.|\.ttl$/}.sort.map {|f| File.join(@dir, f) }
- rescue
- []
- end
-
- def fact_type(file)
- extension = File.extname(file)
-
- type = @types[extension] || :unknown
-
- type = :script if type == :unknown && File.executable?(file)
-
- return type
- end
-
- def txt_parser(file)
- File.readlines(file).each do |line|
- if line =~ /^(.+)=(.+)$/
- var = $1; val = $2
-
- Facter.add(var) do
- setcode { val }
- end
- end
- end
- rescue Exception => e
- Facter.warn("Failed to handle #{file} as text facts: #{e.class}: #{e}")
- end
-
- def json_parser(file)
- begin
- require 'json'
- rescue LoadError
- require 'rubygems'
- retry
- end
-
- JSON.load(File.read(file)).each_pair do |f, v|
- Facter.add(f) do
- setcode { v }
- end
- end
- rescue Exception => e
- Facter.warn("Failed to handle #{file} as json facts: #{e.class}: #{e}")
- end
-
- def yaml_parser(file)
- require 'yaml'
-
- YAML.load_file(file).each_pair do |f, v|
- Facter.add(f) do
- setcode { v }
- end
- end
- rescue Exception => e
- Facter.warn("Failed to handle #{file} as yaml facts: #{e.class}: #{e}")
- end
-
- def script_parser(file)
- result = cache_lookup(file)
- ttl = cache_time(file)
-
- unless result
- result = Facter::Util::Resolution.exec(file)
-
- if ttl > 0
- Facter.debug("Updating cache for #{file}")
- cache_store(file, result)
- cache_save!
- end
- else
- Facter.debug("Using cached data for #{file}")
- end
-
- result.split("\n").each do |line|
- if line =~ /^(.+)=(.+)$/
- var = $1; val = $2
-
- Facter.add(var) do
- setcode { val }
- end
- end
- end
- rescue Exception => e
- Facter.warn("Failed to handle #{file} as script facts: #{e.class}: #{e}")
- Facter.debug(e.backtrace.join("\n\t"))
- end
-
- def cache_save!
- cache = load_cache
- File.open(@cache_file, "w", 0600) {|f| f.write(YAML.dump(cache)) }
- rescue
- end
-
- def cache_store(file, data)
- load_cache
-
- @cache[file] = {:data => data, :stored => Time.now.to_i}
- rescue
- end
-
- def cache_lookup(file)
- cache = load_cache
-
- return nil if cache.empty?
-
- ttl = cache_time(file)
-
- if cache[file]
- now = Time.now.to_i
-
- return cache[file][:data] if ttl == -1
- return cache[file][:data] if (now - cache[file][:stored]) <= ttl
- return nil
- else
- return nil
- end
- rescue
- return nil
- end
-
- def cache_time(file)
- meta = file + ".ttl"
-
- return File.read(meta).chomp.to_i
- rescue
- return 0
- end
-
- def load_cache
- unless @cache
- if File.exist?(@cache_file)
- @cache = YAML.load_file(@cache_file)
- else
- @cache = {}
- end
- end
-
- return @cache
- rescue
- @cache = {}
- return @cache
- end
-
- def create
- entries.each do |fact|
- type = fact_type(fact)
- parser = "#{type}_parser"
-
- if respond_to?("#{type}_parser")
- Facter.debug("Parsing #{fact} using #{parser}")
-
- send(parser, fact)
- end
- end
- end
-end
-
-Facter::Util::DotD.new("/etc/facter/facts.d").create
-Facter::Util::DotD.new("/etc/puppetlabs/facter/facts.d").create
+++ /dev/null
-# A facter fact to determine the root home directory.
-# This varies on PE supported platforms and may be
-# reconfigured by the end user.
-
-module Facter::Util::RootHome
- class << self
- def get_root_home
- root_ent = Facter::Util::Resolution.exec("getent passwd root")
- # The home directory is the sixth element in the passwd entry
- root_ent.split(":")[5]
- end
- end
-end
-
-Facter.add(:root_home) do
- setcode { Facter::Util::RootHome.get_root_home }
-end
+++ /dev/null
-#
-# abs.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:abs, :type => :rvalue, :doc => <<-EOS
- Returns the absolute value of a number, for example -34.56 becomes
- 34.56. Takes a single integer and float value as an argument.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "abs(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
-
- # Numbers in Puppet are often string-encoded which is troublesome ...
- if value.is_a?(String)
- if value.match(/^-?(?:\d+)(?:\.\d+){1}$/)
- value = value.to_f
- elsif value.match(/^-?\d+$/)
- value = value.to_i
- else
- raise(Puppet::ParseError, 'abs(): Requires float or ' +
- 'integer to work with')
- end
- end
-
- # We have numeric value to handle ...
- result = value.abs
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# bool2num.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:bool2num, :type => :rvalue, :doc => <<-EOS
- Converts a boolean to a number. Converts the values:
- false, f, 0, n, and no to 0
- true, t, 1, y, and yes to 1
- Requires a single boolean or string as an input.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "bool2num(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- # We can have either true or false, or string which resembles boolean ...
- unless [FalseClass, TrueClass, String].include?(klass)
- raise(Puppet::ParseError, 'bool2num(): Requires either ' +
- 'boolean or string to work with')
- end
-
- if value.is_a?(String)
- # We consider all the yes, no, y, n and so on too ...
- value = case value
- #
- # This is how undef looks like in Puppet ...
- # We yield 0 (or false if you wish) in this case.
- #
- when /^$/, '' then false # Empty string will be false ...
- when /^(1|t|y|true|yes)$/ then true
- when /^(0|f|n|false|no)$/ then false
- when /^(undef|undefined)$/ then false # This is not likely to happen ...
- else
- raise(Puppet::ParseError, 'bool2num(): Unknown type of boolean given')
- end
- end
-
- # We have real boolean values as well ...
- result = value ? 1 : 0
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# capitalize.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:capitalize, :type => :rvalue, :doc => <<-EOS
- Capitalizes the first letter of a string or array of strings.
- Requires either a single string or an array as an input.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "capitalize(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'capitalize(): Requires either ' +
- 'array or string to work with')
- end
-
- if value.is_a?(Array)
- # Numbers in Puppet are often string-encoded which is troublesome ...
- result = value.collect { |i| i.is_a?(String) ? i.capitalize : i }
- else
- result = value.capitalize
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# chomp.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:chomp, :type => :rvalue, :doc => <<-'EOS'
- Removes the record separator from the end of a string or an array of
- strings, for example `hello\n` becomes `hello`.
- Requires a single string or array as an input.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "chomp(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'chomp(): Requires either ' +
- 'array or string to work with')
- end
-
- if value.is_a?(Array)
- # Numbers in Puppet are often string-encoded which is troublesome ...
- result = value.collect { |i| i.is_a?(String) ? i.chomp : i }
- else
- result = value.chomp
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# chop.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:chop, :type => :rvalue, :doc => <<-'EOS'
- Returns a new string with the last character removed. If the string ends
- with `\r\n`, both characters are removed. Applying chop to an empty
- string returns an empty string. If you wish to merely remove record
- separators then you should use the `chomp` function.
- Requires a string or array of strings as input.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "chop(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'chop(): Requires either an ' +
- 'array or string to work with')
- end
-
- if value.is_a?(Array)
- # Numbers in Puppet are often string-encoded which is troublesome ...
- result = value.collect { |i| i.is_a?(String) ? i.chop : i }
- else
- result = value.chop
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# delete.rb
-#
-
-# TODO(Krzysztof Wilczynski): We need to add support for regular expression ...
-# TODO(Krzysztof Wilczynski): Support for strings and hashes too ...
-
-module Puppet::Parser::Functions
- newfunction(:delete, :type => :rvalue, :doc => <<-EOS
-Deletes a selected element from an array.
-
-*Examples:*
-
- delete(['a','b','c'], 'b')
-
-Would return: ['a','c']
- EOS
- ) do |arguments|
-
- if (arguments.size != 2) then
- raise(Puppet::ParseError, "delete(): Wrong number of arguments "+
- "given #{arguments.size} for 2")
- end
-
- a = arguments[0]
- item = arguments[1]
-
- a.delete(item)
- a
-
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# delete_at.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:delete_at, :type => :rvalue, :doc => <<-EOS
-Deletes a determined indexed value from an array.
-
-*Examples:*
-
- delete_at(['a','b','c'], 1)
-
-Would return: ['a','c']
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "delete_at(): Wrong number of arguments " +
- "given (#{arguments.size} for 2)") if arguments.size < 2
-
- array = arguments[0]
-
- unless array.is_a?(Array)
- raise(Puppet::ParseError, 'delete_at(): Requires array to work with')
- end
-
- index = arguments[1]
-
- if index.is_a?(String) and not index.match(/^\d+$/)
- raise(Puppet::ParseError, 'delete_at(): You must provide ' +
- 'non-negative numeric index')
- end
-
- result = array.clone
-
- # Numbers in Puppet are often string-encoded which is troublesome ...
- index = index.to_i
-
- if index > result.size - 1 # First element is at index 0 is it not?
- raise(Puppet::ParseError, 'delete_at(): Given index ' +
- 'exceeds size of array given')
- end
-
- result.delete_at(index) # We ignore the element that got deleted ...
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# downcase.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:downcase, :type => :rvalue, :doc => <<-EOS
-Converts the case of a string or all strings in an array to lower case.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "downcase(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'downcase(): Requires either ' +
- 'array or string to work with')
- end
-
- if value.is_a?(Array)
- # Numbers in Puppet are often string-encoded which is troublesome ...
- result = value.collect { |i| i.is_a?(String) ? i.downcase : i }
- else
- result = value.downcase
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# empty.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:empty, :type => :rvalue, :doc => <<-EOS
-Returns true if the variable is empty.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "empty(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, Hash, String].include?(klass)
- raise(Puppet::ParseError, 'empty(): Requires either ' +
- 'array, hash or string to work with')
- end
-
- result = value.empty?
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# flatten.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:flatten, :type => :rvalue, :doc => <<-EOS
-This function flattens any deeply nested arrays and returns a single flat array
-as a result.
-
-*Examples:*
-
- flatten(['a', ['b', ['c']]])
-
-Would return: ['a','b','c']
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "flatten(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- array = arguments[0]
-
- unless array.is_a?(Array)
- raise(Puppet::ParseError, 'flatten(): Requires array to work with')
- end
-
- result = array.flatten
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-module Puppet::Parser::Functions
-
- newfunction(:getvar, :type => :rvalue, :doc => <<-'ENDHEREDOC') do |args|
- Lookup a variable in a remote namespace.
-
- For example:
-
- $foo = getvar('site::data::foo')
- # Equivalent to $foo = $site::data::foo
-
- This is useful if the namespace itself is stored in a string:
-
- $datalocation = 'site::data'
- $bar = getvar("${datalocation}::bar")
- # Equivalent to $bar = $site::data::bar
- ENDHEREDOC
-
- unless args.length == 1
- raise Puppet::ParseError, ("getvar(): wrong number of arguments (#{args.length}; must be 1)")
- end
-
- self.lookupvar("#{args[0]}")
-
- end
-
-end
+++ /dev/null
-#
-# grep.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:grep, :type => :rvalue, :doc => <<-EOS
-This function searches through an array and returns any elements that match
-the provided regular expression.
-
-*Examples:*
-
- grep(['aaa','bbb','ccc','aaaddd'], 'aaa')
-
-Would return:
-
- ['aaa','aaaddd']
- EOS
- ) do |arguments|
-
- if (arguments.size != 2) then
- raise(Puppet::ParseError, "grep(): Wrong number of arguments "+
- "given #{arguments.size} for 2")
- end
-
- a = arguments[0]
- pattern = Regexp.new(arguments[1])
-
- a.grep(pattern)
-
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-module Puppet::Parser::Functions
-
- newfunction(:has_key, :type => :rvalue, :doc => <<-'ENDHEREDOC') do |args|
- Determine if a hash has a certain key value.
-
- Example:
-
- $my_hash = {'key_one' => 'value_one'}
- if has_key($my_hash, 'key_two') {
- notice('we will not reach here')
- }
- if has_key($my_hash, 'key_one') {
- notice('this will be printed')
- }
-
- ENDHEREDOC
-
- unless args.length == 2
- raise Puppet::ParseError, ("has_key(): wrong number of arguments (#{args.length}; must be 2)")
- end
- unless args[0].is_a?(Hash)
- raise Puppet::ParseError, "has_key(): expects the first argument to be a hash, got #{args[0].inspect} which is of type #{args[0].class}"
- end
- args[0].has_key?(args[1])
-
- end
-
-end
+++ /dev/null
-#
-# hash.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:hash, :type => :rvalue, :doc => <<-EOS
-This function converts and array into a hash.
-
-*Examples:*
-
- hash(['a',1,'b',2,'c',3])
-
-Would return: {'a'=>1,'b'=>2,'c'=>3}
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "hash(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- array = arguments[0]
-
- unless array.is_a?(Array)
- raise(Puppet::ParseError, 'hash(): Requires array to work with')
- end
-
- result = {}
-
- begin
- # This is to make it compatible with older version of Ruby ...
- array = array.flatten
- result = Hash[*array]
- rescue Exception
- raise(Puppet::ParseError, 'hash(): Unable to compute ' +
- 'hash from array given')
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# is_array.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:is_array, :type => :rvalue, :doc => <<-EOS
-Returns true if the variable passed to this function is an array.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "is_array(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- type = arguments[0]
-
- result = type.is_a?(Array)
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# is_domain_name.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:is_domain_name, :type => :rvalue, :doc => <<-EOS
-Returns true if the string passed to this function is a valid IP address. Support for IPv4 and IPv6 address types is included.
- EOS
- ) do |arguments|
-
- if (arguments.size != 1) then
- raise(Puppet::ParseError, "is_domain_name(): Wrong number of arguments "+
- "given #{arguments.size} for 1")
- end
-
- domain = arguments[0]
-
- if domain =~ /^(([a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])\.?$/ then
- return true
- else
- return false
- end
-
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# is_float.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:is_float, :type => :rvalue, :doc => <<-EOS
-Returns true if the variable passed to this function is a float.
- EOS
- ) do |arguments|
-
- if (arguments.size != 1) then
- raise(Puppet::ParseError, "is_float(): Wrong number of arguments "+
- "given #{arguments.size} for 1")
- end
-
- value = arguments[0]
-
- if value != value.to_f.to_s then
- return false
- else
- return true
- end
-
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# is_hash.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:is_hash, :type => :rvalue, :doc => <<-EOS
-Returns true if the variable passed to this function is a hash.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "is_hash(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size != 1
-
- type = arguments[0]
-
- result = type.is_a?(Hash)
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# is_integer.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:is_integer, :type => :rvalue, :doc => <<-EOS
-Returns true if the variable returned to this string is an integer.
- EOS
- ) do |arguments|
-
- if (arguments.size != 1) then
- raise(Puppet::ParseError, "is_integer(): Wrong number of arguments "+
- "given #{arguments.size} for 1")
- end
-
- value = arguments[0]
-
- if value != value.to_i.to_s then
- return false
- else
- return true
- end
-
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# is_ip_address.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:is_ip_address, :type => :rvalue, :doc => <<-EOS
-Returns true if the string passed to this function is a valid IP address.
- EOS
- ) do |arguments|
-
- require 'ipaddr'
-
- if (arguments.size != 1) then
- raise(Puppet::ParseError, "is_ip_address(): Wrong number of arguments "+
- "given #{arguments.size} for 1")
- end
-
- begin
- ip = IPAddr.new(arguments[0])
- rescue ArgumentError
- return false
- end
-
- if ip.ipv4? or ip.ipv6? then
- return true
- else
- return false
- end
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# is_mac_address.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:is_mac_address, :type => :rvalue, :doc => <<-EOS
-Returns true if the string passed to this function is a valid mac address.
- EOS
- ) do |arguments|
-
- if (arguments.size != 1) then
- raise(Puppet::ParseError, "is_mac_address(): Wrong number of arguments "+
- "given #{arguments.size} for 1")
- end
-
- mac = arguments[0]
-
- if /^[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}:[a-fA-F0-9]{1,2}$/.match(mac) then
- return true
- else
- return false
- end
-
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# is_numeric.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:is_numeric, :type => :rvalue, :doc => <<-EOS
-Returns true if the variable passed to this function is a number.
- EOS
- ) do |arguments|
-
- if (arguments.size != 1) then
- raise(Puppet::ParseError, "is_numeric(): Wrong number of arguments "+
- "given #{arguments.size} for 1")
- end
-
- value = arguments[0]
-
- if value == value.to_f.to_s or value == value.to_i.to_s then
- return true
- else
- return false
- end
-
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# is_string.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:is_string, :type => :rvalue, :doc => <<-EOS
-Returns true if the variable passed to this function is a string.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "is_string(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- type = arguments[0]
-
- result = type.is_a?(String)
-
- if result and (type == type.to_f.to_s or type == type.to_i.to_s) then
- return false
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# join.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:join, :type => :rvalue, :doc => <<-EOS
-This function joins an array into a string using a seperator.
-
-*Examples:*
-
- join(['a','b','c'], ",")
-
-Would result in: "a,b,c"
- EOS
- ) do |arguments|
-
- # Technically we support two arguments but only first is mandatory ...
- raise(Puppet::ParseError, "join(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- array = arguments[0]
-
- unless array.is_a?(Array)
- raise(Puppet::ParseError, 'join(): Requires array to work with')
- end
-
- suffix = arguments[1] if arguments[1]
-
- if suffix
- unless suffix.is_a?(String)
- raise(Puppet::ParseError, 'join(): Requires string to work with')
- end
- end
-
- result = suffix ? array.join(suffix) : array.join
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# keys.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:keys, :type => :rvalue, :doc => <<-EOS
-Returns the keys of a hash as an array.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "keys(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- hash = arguments[0]
-
- unless hash.is_a?(Hash)
- raise(Puppet::ParseError, 'keys(): Requires hash to work with')
- end
-
- result = hash.keys
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-module Puppet::Parser::Functions
-
- newfunction(:loadyaml, :type => :rvalue, :doc => <<-'ENDHEREDOC') do |args|
- Load a YAML file containing an array, string, or hash, and return the data
- in the corresponding native data type.
-
- For example:
-
- $myhash = loadyaml('/etc/puppet/data/myhash.yaml')
- ENDHEREDOC
-
- unless args.length == 1
- raise Puppet::ParseError, ("loadyaml(): wrong number of arguments (#{args.length}; must be 1)")
- end
-
- YAML.load_file(args[0])
-
- end
-
-end
+++ /dev/null
-#
-# lstrip.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:lstrip, :type => :rvalue, :doc => <<-EOS
-Strips leading spaces to the left of a string.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "lstrip(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'lstrip(): Requires either ' +
- 'array or string to work with')
- end
-
- if value.is_a?(Array)
- # Numbers in Puppet are often string-encoded which is troublesome ...
- result = value.collect { |i| i.is_a?(String) ? i.lstrip : i }
- else
- result = value.lstrip
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# member.rb
-#
-
-# TODO(Krzysztof Wilczynski): We need to add support for regular expression ...
-# TODO(Krzysztof Wilczynski): Support for strings and hashes too ...
-
-module Puppet::Parser::Functions
- newfunction(:member, :type => :rvalue, :doc => <<-EOS
-This function determines if a variable is a member of an array.
-
-*Examples:*
-
- member(['a','b'], 'b')
-
-Would return: true
-
- member(['a','b'], 'c')
-
-Would return: false
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "member(): Wrong number of arguments " +
- "given (#{arguments.size} for 2)") if arguments.size < 2
-
- array = arguments[0]
-
- unless array.is_a?(Array)
- raise(Puppet::ParseError, 'member(): Requires array to work with')
- end
-
- item = arguments[1]
-
- raise(Puppet::ParseError, 'member(): You must provide item ' +
- 'to search for within array given') if item.empty?
-
- result = array.include?(item)
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-module Puppet::Parser::Functions
- newfunction(:merge, :type => :rvalue, :doc => <<-'ENDHEREDOC') do |args|
- Merges two or more hashes together and returns the resulting hash.
-
- For example:
-
- $hash1 = {'one' => 1, 'two', => 2}
- $hash2 = {'two' => 'dos', 'three', => 'tres'}
- $merged_hash = merge($hash1, $hash2)
- # The resulting hash is equivalent to:
- # $merged_hash = {'one' => 1, 'two' => 'dos', 'three' => 'tres'}
-
- When there is a duplicate key, the key in the rightmost hash will "win."
-
- ENDHEREDOC
-
- if args.length < 2
- raise Puppet::ParseError, ("merge(): wrong number of arguments (#{args.length}; must be at least 2)")
- end
-
- # The hash we accumulate into
- accumulator = Hash.new
- # Merge into the accumulator hash
- args.each do |arg|
- unless arg.is_a?(Hash)
- raise Puppet::ParseError, "merge: unexpected argument type #{arg.class}, only expects hash arguments"
- end
- accumulator.merge!(arg)
- end
- # Return the fully merged hash
- accumulator
- end
-end
+++ /dev/null
-#
-# num2bool.rb
-#
-
-# TODO(Krzysztof Wilczynski): We probably need to approach numeric values differently ...
-
-module Puppet::Parser::Functions
- newfunction(:num2bool, :type => :rvalue, :doc => <<-EOS
-This function converts a number into a true boolean. Zero becomes false. Numbers
-higher then 0 become true.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "num2bool(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- number = arguments[0]
-
- # Only numbers allowed ...
- unless number.match(/^\-?\d+$/)
- raise(Puppet::ParseError, 'num2bool(): Requires integer to work with')
- end
-
- result = case number
- when /^0$/
- false
- when /^\-?\d+$/
- # Numbers in Puppet are often string-encoded which is troublesome ...
- number = number.to_i
- # We yield true for any positive number and false otherwise ...
- number > 0 ? true : false
- else
- raise(Puppet::ParseError, 'num2bool(): Unknown numeric format given')
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# parsejson.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:parsejson, :type => :rvalue, :doc => <<-EOS
-This function accepts JSON as a string and converts into the correct Puppet
-structure.
- EOS
- ) do |arguments|
-
- if (arguments.size != 1) then
- raise(Puppet::ParseError, "parsejson(): Wrong number of arguments "+
- "given #{arguments.size} for 1")
- end
-
- json = arguments[0]
-
- # PSON is natively available in puppet
- PSON.load(json)
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# parseyaml.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:parseyaml, :type => :rvalue, :doc => <<-EOS
-This function accepts YAML as a string and converts it into the correct
-Puppet structure.
- EOS
- ) do |arguments|
-
- if (arguments.size != 1) then
- raise(Puppet::ParseError, "parseyaml(): Wrong number of arguments "+
- "given #{arguments.size} for 1")
- end
-
- require 'yaml'
-
- YAML::load(arguments[0])
-
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# prefix.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:prefix, :type => :rvalue, :doc => <<-EOS
-This function applies a prefix to all elements in an array.
-
-*Examles:*
-
- prefix(['a','b','c'], 'p')
-
-Will return: ['pa','pb','pc']
- EOS
- ) do |arguments|
-
- # Technically we support two arguments but only first is mandatory ...
- raise(Puppet::ParseError, "prefix(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- array = arguments[0]
-
- unless array.is_a?(Array)
- raise(Puppet::ParseError, 'prefix(): Requires array to work with')
- end
-
- prefix = arguments[1] if arguments[1]
-
- if prefix
- unless prefix.is_a?(String)
- raise(Puppet::ParseError, 'prefix(): Requires string to work with')
- end
- end
-
- # Turn everything into string same as join would do ...
- result = array.collect do |i|
- i = i.to_s
- prefix ? prefix + i : i
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# range.rb
-#
-
-# TODO(Krzysztof Wilczynski): We probably need to approach numeric values differently ...
-
-module Puppet::Parser::Functions
- newfunction(:range, :type => :rvalue, :doc => <<-EOS
-When given range in the form of (start, stop) it will extrapolate a range as
-an array.
-
-*Examples:*
-
- range("0", "9")
-
-Will return: [0,1,2,3,4,5,6,7,8,9]
-
- range("a", "c")
-
-Will return: ["a","b","c"]
- EOS
- ) do |arguments|
-
- # We support more than one argument but at least one is mandatory ...
- raise(Puppet::ParseError, "range(): Wrong number of " +
- "arguments given (#{arguments.size} for 1)") if arguments.size < 1
-
- if arguments.size > 1
- start = arguments[0]
- stop = arguments[1]
-
- type = '..' # We select simplest type for Range available in Ruby ...
-
- elsif arguments.size > 0
- value = arguments[0]
-
- if m = value.match(/^(\w+)(\.\.\.?|\-)(\w+)$/)
- start = m[1]
- stop = m[3]
-
- type = m[2]
-
- elsif value.match(/^.+$/)
- raise(Puppet::ParseError, 'range(): Unable to compute range ' +
- 'from the value given')
- else
- raise(Puppet::ParseError, 'range(): Unknown format of range given')
- end
- end
-
- # Check whether we have integer value if so then make it so ...
- if start.match(/^\d+$/)
- start = start.to_i
- stop = stop.to_i
- else
- start = start.to_s
- stop = stop.to_s
- end
-
- range = case type
- when /^(\.\.|\-)$/ then (start .. stop)
- when /^(\.\.\.)$/ then (start ... stop) # Exclusive of last element ...
- end
-
- result = range.collect { |i| i } # Get them all ... Pokemon ...
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# reverse.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:reverse, :type => :rvalue, :doc => <<-EOS
-Reverses the order of a string or array.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "reverse(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'reverse(): Requires either ' +
- 'array or string to work with')
- end
-
- result = value.reverse
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# rstrip.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:rstrip, :type => :rvalue, :doc => <<-EOS
-Strips leading spaces to the right of the string.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "rstrip(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'rstrip(): Requires either ' +
- 'array or string to work with')
- end
-
- if value.is_a?(Array)
- result = value.collect { |i| i.is_a?(String) ? i.rstrip : i }
- else
- result = value.rstrip
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# shuffle.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:shuffle, :type => :rvalue, :doc => <<-EOS
-Randomizes the order of a string or array elements.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "shuffle(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'shuffle(): Requires either ' +
- 'array or string to work with')
- end
-
- result = value.clone
-
- string = value.is_a?(String) ? true : false
-
- # Check whether it makes sense to shuffle ...
- return result if result.size <= 1
-
- # We turn any string value into an array to be able to shuffle ...
- result = string ? result.split('') : result
-
- elements = result.size
-
- # Simple implementation of Fisher–Yates in-place shuffle ...
- elements.times do |i|
- j = rand(elements - i) + i
- result[j], result[i] = result[i], result[j]
- end
-
- result = string ? result.join : result
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# size.rb
-#
-
-# TODO(Krzysztof Wilczynski): Support for hashes would be nice too ...
-
-module Puppet::Parser::Functions
- newfunction(:size, :type => :rvalue, :doc => <<-EOS
-Returns the number of elements in a string or array.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "size(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- item = arguments[0]
-
- if item.is_a?(String)
-
- begin
- #
- # Check whether your item is a numeric value or not ...
- # This will take care about positive and/or negative numbers
- # for both integer and floating-point values ...
- #
- # Please note that Puppet has no notion of hexadecimal
- # nor octal numbers for its DSL at this point in time ...
- #
- Float(item)
-
- raise(Puppet::ParseError, 'size(): Requires either ' +
- 'string or array to work with')
-
- rescue ArgumentError
- result = item.size
- end
-
- elsif item.is_a?(Array)
- result = item.size
- else
- raise(Puppet::ParseError, 'size(): Unknown type given')
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# sort.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:sort, :type => :rvalue, :doc => <<-EOS
-Sorts strings and arrays lexically.
- EOS
- ) do |arguments|
-
- if (arguments.size != 1) then
- raise(Puppet::ParseError, "sort(): Wrong number of arguments "+
- "given #{arguments.size} for 1")
- end
-
- value = arguments[0]
-
- if value.is_a?(Array) then
- value.sort
- elsif value.is_a?(String) then
- value.split("").sort.join("")
- end
-
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# squeeze.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:squeeze, :type => :rvalue, :doc => <<-EOS
-Returns a new string where runs of the same character that occur in this set are replaced by a single character.
- EOS
- ) do |arguments|
-
- if ((arguments.size != 2) and (arguments.size != 1)) then
- raise(Puppet::ParseError, "squeeze(): Wrong number of arguments "+
- "given #{arguments.size} for 2 or 1")
- end
-
- item = arguments[0]
- squeezeval = arguments[1]
-
- if item.is_a?(Array) then
- if squeezeval then
- item.collect { |i| i.squeeze(squeezeval) }
- else
- item.collect { |i| i.squeeze }
- end
- else
- if squeezeval then
- item.squeeze(squeezeval)
- else
- item.squeeze
- end
- end
-
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# str2bool.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:str2bool, :type => :rvalue, :doc => <<-EOS
-This converts a string to a boolean. This attempt to convert strings that
-contain things like: y, 1, t, true to 'true' and strings that contain things
-like: 0, f, n, false, no to 'false'.
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "str2bool(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- string = arguments[0]
-
- unless string.is_a?(String)
- raise(Puppet::ParseError, 'str2bool(): Requires either ' +
- 'string to work with')
- end
-
- # We consider all the yes, no, y, n and so on too ...
- result = case string
- #
- # This is how undef looks like in Puppet ...
- # We yield false in this case.
- #
- when /^$/, '' then false # Empty string will be false ...
- when /^(1|t|y|true|yes)$/ then true
- when /^(0|f|n|false|no)$/ then false
- when /^(undef|undefined)$/ then false # This is not likely to happen ...
- else
- raise(Puppet::ParseError, 'str2bool(): Unknown type of boolean given')
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# strftime.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:strftime, :type => :rvalue, :doc => <<-EOS
-This function returns formatted time.
-
-*Examples:*
-
-To return the time since epoch:
-
- strftime("%s")
-
-To return the date:
-
- strftime("%Y-%m-%d")
-
-*Format meaning:*
-
- %a - The abbreviated weekday name (``Sun'')
- %A - The full weekday name (``Sunday'')
- %b - The abbreviated month name (``Jan'')
- %B - The full month name (``January'')
- %c - The preferred local date and time representation
- %C - Century (20 in 2009)
- %d - Day of the month (01..31)
- %D - Date (%m/%d/%y)
- %e - Day of the month, blank-padded ( 1..31)
- %F - Equivalent to %Y-%m-%d (the ISO 8601 date format)
- %h - Equivalent to %b
- %H - Hour of the day, 24-hour clock (00..23)
- %I - Hour of the day, 12-hour clock (01..12)
- %j - Day of the year (001..366)
- %k - hour, 24-hour clock, blank-padded ( 0..23)
- %l - hour, 12-hour clock, blank-padded ( 0..12)
- %L - Millisecond of the second (000..999)
- %m - Month of the year (01..12)
- %M - Minute of the hour (00..59)
- %n - Newline (\n)
- %N - Fractional seconds digits, default is 9 digits (nanosecond)
- %3N millisecond (3 digits)
- %6N microsecond (6 digits)
- %9N nanosecond (9 digits)
- %p - Meridian indicator (``AM'' or ``PM'')
- %P - Meridian indicator (``am'' or ``pm'')
- %r - time, 12-hour (same as %I:%M:%S %p)
- %R - time, 24-hour (%H:%M)
- %s - Number of seconds since 1970-01-01 00:00:00 UTC.
- %S - Second of the minute (00..60)
- %t - Tab character (\t)
- %T - time, 24-hour (%H:%M:%S)
- %u - Day of the week as a decimal, Monday being 1. (1..7)
- %U - Week number of the current year,
- starting with the first Sunday as the first
- day of the first week (00..53)
- %v - VMS date (%e-%b-%Y)
- %V - Week number of year according to ISO 8601 (01..53)
- %W - Week number of the current year,
- starting with the first Monday as the first
- day of the first week (00..53)
- %w - Day of the week (Sunday is 0, 0..6)
- %x - Preferred representation for the date alone, no time
- %X - Preferred representation for the time alone, no date
- %y - Year without a century (00..99)
- %Y - Year with century
- %z - Time zone as hour offset from UTC (e.g. +0900)
- %Z - Time zone name
- %% - Literal ``%'' character
- EOS
- ) do |arguments|
-
- # Technically we support two arguments but only first is mandatory ...
- raise(Puppet::ParseError, "strftime(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- format = arguments[0]
-
- raise(Puppet::ParseError, 'strftime(): You must provide ' +
- 'format for evaluation') if format.empty?
-
- # The Time Zone argument is optional ...
- time_zone = arguments[1] if arguments[1]
-
- time = Time.new
-
- # There is probably a better way to handle Time Zone ...
- if time_zone and not time_zone.empty?
- original_zone = ENV['TZ']
-
- local_time = time.clone
- local_time = local_time.utc
-
- ENV['TZ'] = time_zone
-
- time = local_time.localtime
-
- ENV['TZ'] = original_zone
- end
-
- result = time.strftime(format)
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# strip.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:strip, :type => :rvalue, :doc => <<-EOS
-This function removes leading and trailing whitespace from a string or from
-every string inside an array.
-
-*Examples:*
-
- strip(" aaa ")
-
-Would result in: "aaa"
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "strip(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'strip(): Requires either ' +
- 'array or string to work with')
- end
-
- if value.is_a?(Array)
- result = value.collect { |i| i.is_a?(String) ? i.strip : i }
- else
- result = value.strip
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# swapcase.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:swapcase, :type => :rvalue, :doc => <<-EOS
-This function will swap the existing case of a string.
-
-*Examples:*
-
- swapcase("aBcD")
-
-Would result in: "AbCd"
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "swapcase(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'swapcase(): Requires either ' +
- 'array or string to work with')
- end
-
- if value.is_a?(Array)
- # Numbers in Puppet are often string-encoded which is troublesome ...
- result = value.collect { |i| i.is_a?(String) ? i.swapcase : i }
- else
- result = value.swapcase
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# time.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:time, :type => :rvalue, :doc => <<-EOS
-This function will return the current time since epoch as an integer.
-
-*Examples:*
-
- time()
-
-Will return something like: 1311972653
- EOS
- ) do |arguments|
-
- # The Time Zone argument is optional ...
- time_zone = arguments[0] if arguments[0]
-
- if (arguments.size != 0) and (arguments.size != 1) then
- raise(Puppet::ParseError, "time(): Wrong number of arguments "+
- "given #{arguments.size} for 0 or 1")
- end
-
- time = Time.new
-
- # There is probably a better way to handle Time Zone ...
- if time_zone and not time_zone.empty?
- original_zone = ENV['TZ']
-
- local_time = time.clone
- local_time = local_time.utc
-
- ENV['TZ'] = time_zone
-
- time = local_time.localtime
-
- ENV['TZ'] = original_zone
- end
-
- # Calling Time#to_i on a receiver changes it. Trust me I am the Doctor.
- result = time.strftime('%s')
- result = result.to_i
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# type.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:type, :type => :rvalue, :doc => <<-EOS
-Returns the type when passed a variable. Type can be one of:
-
-* string
-* array
-* hash
-* float
-* integer
-* boolean
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "type(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
-
- klass = value.class
-
- if not [TrueClass, FalseClass, Array, Bignum, Fixnum, Float, Hash, String].include?(klass)
- raise(Puppet::ParseError, 'type(): Unknown type')
- end
-
- klass = klass.to_s # Ugly ...
-
- # We note that Integer is the parent to Bignum and Fixnum ...
- result = case klass
- when /^(?:Big|Fix)num$/ then 'integer'
- when /^(?:True|False)Class$/ then 'boolean'
- else klass
- end
-
- if result == "String" then
- if value == value.to_i.to_s then
- result = "Integer"
- elsif value == value.to_f.to_s then
- result = "Float"
- end
- end
-
- return result.downcase
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# unique.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:unique, :type => :rvalue, :doc => <<-EOS
-This function will remove duplicates from strings and arrays.
-
-*Examples:*
-
- unique("aabbcc")
-
-Will return:
-
- abc
-
-You can also use this with arrays:
-
- unique(["a","a","b","b","c","c"])
-
-This returns:
-
- ["a","b","c"]
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "unique(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'unique(): Requires either ' +
- 'array or string to work with')
- end
-
- result = value.clone
-
- string = value.is_a?(String) ? true : false
-
- # We turn any string value into an array to be able to shuffle ...
- result = string ? result.split('') : result
- result = result.uniq # Remove duplicates ...
- result = string ? result.join : result
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# upcase.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:upcase, :type => :rvalue, :doc => <<-EOS
-Converts a string or an array of strings to uppercase.
-
-*Examples:*
-
- upcase("abcd")
-
-Will return:
-
- ASDF
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "upcase(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- value = arguments[0]
- klass = value.class
-
- unless [Array, String].include?(klass)
- raise(Puppet::ParseError, 'upcase(): Requires either ' +
- 'array or string to work with')
- end
-
- if value.is_a?(Array)
- # Numbers in Puppet are often string-encoded which is troublesome ...
- result = value.collect { |i| i.is_a?(String) ? i.upcase : i }
- else
- result = value.upcase
- end
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-module Puppet::Parser::Functions
-
- newfunction(:validate_array, :doc => <<-'ENDHEREDOC') do |args|
- Validate that all passed values are array data structures. Abort catalog
- compilation if any value fails this check.
-
- The following values will pass:
-
- $my_array = [ 'one', 'two' ]
- validate_array($my_array)
-
- The following values will fail, causing compilation to abort:
-
- validate_array(true)
- validate_array('some_string')
- $undefined = undef
- validate_array($undefined)
-
- ENDHEREDOC
-
- unless args.length > 0 then
- raise Puppet::ParseError, ("validate_array(): wrong number of arguments (#{args.length}; must be > 0)")
- end
-
- args.each do |arg|
- unless arg.is_a?(Array)
- raise Puppet::ParseError, ("#{arg.inspect} is not an Array. It looks to be a #{arg.class}")
- end
- end
-
- end
-
-end
+++ /dev/null
-module Puppet::Parser::Functions
-
- newfunction(:validate_bool, :doc => <<-'ENDHEREDOC') do |args|
- Validate that all passed values are either true or false. Abort catalog
- compilation if any value fails this check.
-
- The following values will pass:
-
- $iamtrue = true
- validate_bool(true)
- validate_bool(true, true, false, $iamtrue)
-
- The following values will fail, causing compilation to abort:
-
- $some_array = [ true ]
- validate_bool("false")
- validate_bool("true")
- validate_bool($some_array)
-
- ENDHEREDOC
-
- unless args.length > 0 then
- raise Puppet::ParseError, ("validate_bool(): wrong number of arguments (#{args.length}; must be > 0)")
- end
-
- args.each do |arg|
- unless (arg.is_a?(TrueClass) || arg.is_a?(FalseClass))
- raise Puppet::ParseError, ("#{arg.inspect} is not a boolean. It looks to be a #{arg.class}")
- end
- end
-
- end
-
-end
+++ /dev/null
-module Puppet::Parser::Functions
-
- newfunction(:validate_hash, :doc => <<-'ENDHEREDOC') do |args|
- Validate that all passed values are hash data structures. Abort catalog
- compilation if any value fails this check.
-
- The following values will pass:
-
- $my_hash = { 'one' => 'two' }
- validate_hash($my_hash)
-
- The following values will fail, causing compilation to abort:
-
- validate_hash(true)
- validate_hash('some_string')
- $undefined = undef
- validate_hash($undefined)
-
- ENDHEREDOC
-
- unless args.length > 0 then
- raise Puppet::ParseError, ("validate_hash(): wrong number of arguments (#{args.length}; must be > 0)")
- end
-
- args.each do |arg|
- unless arg.is_a?(Hash)
- raise Puppet::ParseError, ("#{arg.inspect} is not a Hash. It looks to be a #{arg.class}")
- end
- end
-
- end
-
-end
+++ /dev/null
-module Puppet::Parser::Functions
-
- newfunction(:validate_re, :doc => <<-'ENDHEREDOC') do |args|
- Perform simple validation of a string against one or more regular
- expressions. The first argument of this function should be a string to
- test, and the second argument should be a stringified regular expression
- (without the // delimiters) or an array of regular expressions. If none
- of the regular expressions match the string passed in, compilation will
- abort with a parse error.
-
- The following strings will validate against the regular expressions:
-
- validate_re('one', '^one$')
- validate_re('one', [ '^one', '^two' ])
-
- The following strings will fail to validate, causing compilation to abort:
-
- validate_re('one', [ '^two', '^three' ])
-
- ENDHEREDOC
- if args.length != 2 then
- raise Puppet::ParseError, ("validate_re(): wrong number of arguments (#{args.length}; must be 2)")
- end
-
- msg = "validate_re(): #{args[0].inspect} does not match #{args[1].inspect}"
-
- raise Puppet::ParseError, (msg) unless args[1].any? do |re_str|
- args[0] =~ Regexp.compile(re_str)
- end
-
- end
-
-end
+++ /dev/null
-module Puppet::Parser::Functions
-
- newfunction(:validate_string, :doc => <<-'ENDHEREDOC') do |args|
- Validate that all passed values are string data structures. Abort catalog
- compilation if any value fails this check.
-
- The following values will pass:
-
- $my_string = "one two"
- validate_string($my_string, 'three')
-
- The following values will fail, causing compilation to abort:
-
- validate_string(true)
- validate_string([ 'some', 'array' ])
- $undefined = undef
- validate_string($undefined)
-
- ENDHEREDOC
-
- unless args.length > 0 then
- raise Puppet::ParseError, ("validate_string(): wrong number of arguments (#{args.length}; must be > 0)")
- end
-
- args.each do |arg|
- unless arg.is_a?(String)
- raise Puppet::ParseError, ("#{arg.inspect} is not a string. It looks to be a #{arg.class}")
- end
- end
-
- end
-
-end
+++ /dev/null
-#
-# values.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:values, :type => :rvalue, :doc => <<-EOS
-When given a hash this function will return the values of that hash.
-
-*Examples:*
-
- $hash = {
- 'a' => 1,
- 'b' => 2,
- 'c' => 3,
- }
- values($hash)
-
-This example would return:
-
- [1,2,3]
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "values(): Wrong number of arguments " +
- "given (#{arguments.size} for 1)") if arguments.size < 1
-
- hash = arguments[0]
-
- unless hash.is_a?(Hash)
- raise(Puppet::ParseError, 'values(): Requires hash to work with')
- end
-
- result = hash.values
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# values_at.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:values_at, :type => :rvalue, :doc => <<-EOS
-Finds value inside an array based on location.
-
-The first argument is the array you want to analyze, and the second element can
-be a combination of:
-
-* A single numeric index
-* A range in the form of 'start-stop' (eg. 4-9)
-* An array combining the above
-
-*Examples*:
-
- values_at(['a','b','c'], 2)
-
-Would return ['c'].
-
- values_at(['a','b','c'], ["0-1"])
-
-Would return ['a','b'].
-
- values_at(['a','b','c','d','e'], [0, "2-3"])
-
-Would return ['a','c','d'].
- EOS
- ) do |arguments|
-
- raise(Puppet::ParseError, "values_at(): Wrong number of " +
- "arguments given (#{arguments.size} for 2)") if arguments.size < 2
-
- array = arguments.shift
-
- unless array.is_a?(Array)
- raise(Puppet::ParseError, 'values_at(): Requires array to work with')
- end
-
- indices = [arguments.shift].flatten() # Get them all ... Pokemon ...
-
- if not indices or indices.empty?
- raise(Puppet::ParseError, 'values_at(): You must provide ' +
- 'at least one positive index to collect')
- end
-
- result = []
- indices_list = []
-
- indices.each do |i|
- if m = i.match(/^(\d+)(\.\.\.?|\-)(\d+)$/)
- start = m[1].to_i
- stop = m[3].to_i
-
- type = m[2]
-
- if start > stop
- raise(Puppet::ParseError, 'values_at(): Stop index in ' +
- 'given indices range is smaller than the start index')
- elsif stop > array.size - 1 # First element is at index 0 is it not?
- raise(Puppet::ParseError, 'values_at(): Stop index in ' +
- 'given indices range exceeds array size')
- end
-
- range = case type
- when /^(\.\.|\-)$/ then (start .. stop)
- when /^(\.\.\.)$/ then (start ... stop) # Exclusive of last element ...
- end
-
- range.each { |i| indices_list << i.to_i }
- else
- # Only positive numbers allowed in this case ...
- if not i.match(/^\d+$/)
- raise(Puppet::ParseError, 'values_at(): Unknown format ' +
- 'of given index')
- end
-
- # In Puppet numbers are often string-encoded ...
- i = i.to_i
-
- if i > array.size - 1 # Same story. First element is at index 0 ...
- raise(Puppet::ParseError, 'values_at(): Given index ' +
- 'exceeds array size')
- end
-
- indices_list << i
- end
- end
-
- # We remove nil values as they make no sense in Puppet DSL ...
- result = indices_list.collect { |i| array[i] }.compact
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-#
-# zip.rb
-#
-
-module Puppet::Parser::Functions
- newfunction(:zip, :type => :rvalue, :doc => <<-EOS
-Takes one element from first array and merges corresponding elements from second array. This generates a sequence of n-element arrays, where n is one more than the count of arguments.
-
-*Example:*
-
- zip(['1','2','3'],['4','5','6'])
-
-Would result in:
-
- ["1", "4"], ["2", "5"], ["3", "6"]
- EOS
- ) do |arguments|
-
- # Technically we support three arguments but only first is mandatory ...
- raise(Puppet::ParseError, "zip(): Wrong number of arguments " +
- "given (#{arguments.size} for 2)") if arguments.size < 2
-
- a = arguments[0]
- b = arguments[1]
-
- unless a.is_a?(Array) and b.is_a?(Array)
- raise(Puppet::ParseError, 'zip(): Requires array to work with')
- end
-
- flatten = arguments[2] if arguments[2]
-
- if flatten
- klass = flatten.class
-
- # We can have either true or false, or string which resembles boolean ...
- unless [FalseClass, TrueClass, String].include?(klass)
- raise(Puppet::ParseError, 'zip(): Requires either ' +
- 'boolean or string to work with')
- end
-
- if flatten.is_a?(String)
- # We consider all the yes, no, y, n and so on too ...
- flatten = case flatten
- #
- # This is how undef looks like in Puppet ...
- # We yield false in this case.
- #
- when /^$/, '' then false # Empty string will be false ...
- when /^(1|t|y|true|yes)$/ then true
- when /^(0|f|n|false|no)$/ then false
- when /^(undef|undefined)$/ then false # This is not likely to happen ...
- else
- raise(Puppet::ParseError, 'zip(): Unknown type of boolean given')
- end
- end
- end
-
- result = a.zip(b)
- result = flatten ? result.flatten : result
-
- return result
- end
-end
-
-# vim: set ts=2 sw=2 et :
+++ /dev/null
-Puppet::Type.type(:file_line).provide(:ruby) do
-
- def exists?
- File.readlines(resource[:path]).find do |line|
- line.chomp == resource[:line].chomp
- end
- end
-
- def create
- File.open(resource[:path], 'a') do |fh|
- fh.puts resource[:line]
- end
- end
-
-end
+++ /dev/null
-Puppet::Type.newtype(:anchor) do
- desc <<-'ENDOFDESC'
- A simple resource type intended to be used as an anchor in a composite class.
-
- In Puppet 2.6, when a class declares another class, the resources in the
- interior class are not contained by the exterior class. This interacts badly
- with the pattern of composing complex modules from smaller classes, as it
- makes it impossible for end users to specify order relationships between the
- exterior class and other modules.
-
- The anchor type lets you work around this. By sandwiching any interior
- classes between two no-op resources that _are_ contained by the exterior
- class, you can ensure that all resources in the module are contained.
-
- class ntp {
- # These classes will have the correct order relationship with each
- # other. However, without anchors, they won't have any order
- # relationship to Class['ntp'].
- class { 'ntp::package': }
- -> class { 'ntp::config': }
- -> class { 'ntp::service': }
-
- # These two resources "anchor" the composed classes within the ntp
- # class.
- anchor { 'ntp::begin': } -> Class['ntp::package']
- Class['ntp::service'] -> anchor { 'ntp::end': }
- }
-
- This allows the end user of the ntp module to establish require and before
- relationships with Class['ntp']:
-
- class { 'ntp': } -> class { 'mcollective': }
- class { 'mcollective': } -> class { 'ntp': }
-
- ENDOFDESC
-
- newparam :name do
- desc "The name of the anchor resource."
- end
-
-end
+++ /dev/null
-Puppet::Type.newtype(:file_line) do
-
- desc <<-EOT
- Ensures that a given line is contained within a file. The implementation
- matches the full line, including whitespace at the beginning and end. If
- the line is not contained in the given file, Puppet will add the line to
- ensure the desired state. Multiple resources may be declared to manage
- multiple lines in the same file.
-
- Example:
-
- file_line { 'sudo_rule':
- path => '/etc/sudoers',
- line => '%sudo ALL=(ALL) ALL',
- }
- file_line { 'sudo_rule_nopw':
- path => '/etc/sudoers',
- line => '%sudonopw ALL=(ALL) NOPASSWD: ALL',
- }
-
- In this example, Puppet will ensure both of the specified lines are
- contained in the file /etc/sudoers.
-
- EOT
-
- ensurable do
- defaultto :present
- newvalue(:present) do
- provider.create
- end
- end
-
- newparam(:name, :namevar => true) do
- desc 'arbitrary name used as identity'
- end
-
- newparam(:line) do
- desc 'The line to be appended to the path.'
- end
-
- newparam(:path) do
- desc 'File to possibly append a line to.'
- validate do |value|
- unless (Puppet.features.posix? and value =~ /^\//) or (Puppet.features.microsoft_windows? and (value =~ /^.:\// or value =~ /^\/\/[^\/]+\/[^\/]+/))
- raise(Puppet::Error, "File paths must be fully qualified, not '#{value}'")
- end
- end
- end
-
- validate do
- unless self[:line] and self[:path]
- raise(Puppet::Error, "Both line and path are required attributes")
- end
- end
-end
+++ /dev/null
-# Class: stdlib
-#
-# This module manages stdlib. Most of stdlib's features are automatically
-# loaded by Puppet, but this class should be declared in order to use the
-# standardized run stages.
-#
-# Parameters: none
-#
-# Actions:
-#
-# Declares all other classes in the stdlib module. Currently, this consists
-# of stdlib::stages.
-#
-# Requires: nothing
-#
-class stdlib {
-
- class { 'stdlib::stages': }
-
-}
+++ /dev/null
-# Class: stdlib::stages
-#
-# This class manages a standard set of run stages for Puppet. It is managed by
-# the stdlib class, and should not be declared independently.
-#
-# The high level stages are (in order):
-#
-# * setup
-# * main
-# * runtime
-# * setup_infra
-# * deploy_infra
-# * setup_app
-# * deploy_app
-# * deploy
-#
-# Parameters: none
-#
-# Actions:
-#
-# Declares various run-stages for deploying infrastructure,
-# language runtimes, and application layers.
-#
-# Requires: nothing
-#
-# Sample Usage:
-#
-# node default {
-# include stdlib
-# class { java: stage => 'runtime' }
-# }
-#
-class stdlib::stages {
-
- stage { 'setup': before => Stage['main'] }
- stage { 'runtime': require => Stage['main'] }
- -> stage { 'setup_infra': }
- -> stage { 'deploy_infra': }
- -> stage { 'setup_app': }
- -> stage { 'deploy_app': }
- -> stage { 'deploy': }
-
-}
+++ /dev/null
-{
- "version": "2.2.1",
- "dependencies": [
-
- ],
- "description": "Standard Library for Puppet Modules",
- "types": [
- {
- "parameters": [
- {
- "doc": "The name of the anchor resource.",
- "name": "name"
- }
- ],
- "properties": [
-
- ],
- "doc": " A simple resource type intended to be used as an anchor in a composite class.\n\n In Puppet 2.6, when a class declares another class, the resources in the\n interior class are not contained by the exterior class. This interacts badly\n with the pattern of composing complex modules from smaller classes, as it\n makes it impossible for end users to specify order relationships between the\n exterior class and other modules.\n\n The anchor type lets you work around this. By sandwiching any interior\n classes between two no-op resources that _are_ contained by the exterior\n class, you can ensure that all resources in the module are contained.\n\n class ntp {\n # These classes will have the correct order relationship with each\n # other. However, without anchors, they won't have any order\n # relationship to Class['ntp'].\n class { 'ntp::package': }\n -> class { 'ntp::config': }\n -> class { 'ntp::service': }\n\n # These two resources \"anchor\" the composed classes within the ntp\n # class.\n anchor { 'ntp::begin': } -> Class['ntp::package']\n Class['ntp::service'] -> anchor { 'ntp::end': }\n }\n\n This allows the end user of the ntp module to establish require and before\n relationships with Class['ntp']:\n\n class { 'ntp': } -> class { 'mcollective': }\n class { 'mcollective': } -> class { 'ntp': }\n\n",
- "name": "anchor"
- },
- {
- "parameters": [
- {
- "doc": "arbitrary name used as identity",
- "name": "name"
- },
- {
- "doc": "The line to be appended to the path.",
- "name": "line"
- },
- {
- "doc": "File to possibly append a line to.",
- "name": "path"
- }
- ],
- "providers": [
- {
- "doc": "",
- "name": "ruby"
- }
- ],
- "properties": [
- {
- "doc": " Valid values are `present`.",
- "name": "ensure"
- }
- ],
- "doc": " Ensures that a given line is contained within a file. The implementation\n matches the full line, including whitespace at the beginning and end. If\n the line is not contained in the given file, Puppet will add the line to\n ensure the desired state. Multiple resources may be declared to manage\n multiple lines in the same file.\n\n Example:\n\n file_line { 'sudo_rule':\n path => '/etc/sudoers',\n line => '%sudo ALL=(ALL) ALL',\n }\n file_line { 'sudo_rule_nopw':\n path => '/etc/sudoers',\n line => '%sudonopw ALL=(ALL) NOPASSWD: ALL',\n }\n\n In this example, Puppet will ensure both of the specified lines are\n contained in the file /etc/sudoers.\n\n",
- "name": "file_line"
- }
- ],
- "summary": "Puppet Module Standard Library",
- "source": "git://github.com/puppetlabs/puppetlabs-stdlib",
- "checksums": {
- "spec/unit/puppet/parser/functions/is_mac_address_spec.rb": "38f1dc844e76ab1e653578d7de612377",
- "spec/unit/puppet/parser/functions/type_spec.rb": "750538a9811f9ecdb435f4f3949916d6",
- "lib/puppet/parser/functions/upcase.rb": "a5744a74577cfa136fca2835e75888d3",
- "spec/unit/puppet/parser/functions/swapcase_spec.rb": "1752f73dedae50c90372f50364dd9649",
- "lib/puppet/parser/functions/swapcase.rb": "4902f38f0b9292afec66d40fee4b02ec",
- "spec/unit/puppet/parser/functions/prefix_spec.rb": "2631a72780efb517b19fbb71c058b388",
- "spec/lib/puppet_spec/matchers.rb": "8e77dc7317de7fc2ff289fb716623b6c",
- "spec/unit/puppet/provider/file_line/ruby_spec.rb": "baaf1e9f1679bb813ef6a117c4b0f1ec",
- "spec/unit/puppet/parser/functions/squeeze_spec.rb": "c8656b5502127d418b4c72dcb5247550",
- "lib/puppet/parser/functions/delete_at.rb": "6bc24b79390d463d8be95396c963381a",
- "spec/unit/puppet/parser/functions/member_spec.rb": "16829dd5145e5e29b899885a0be6ce90",
- "lib/puppet/parser/functions/is_mac_address.rb": "288bd4b38d4df42a83681f13e7eaaee0",
- "lib/puppet/parser/functions/abs.rb": "c2f2c4a62a56e7adbf5cf0b292e081fc",
- "lib/puppet/parser/functions/strftime.rb": "e02e01a598ca5d7d6eee0ba22440304a",
- "spec/unit/puppet/parser/functions/hash_spec.rb": "546657ec64d425d6db4bec068c7fa8ab",
- "lib/puppet/parser/functions/is_hash.rb": "8c7d9a05084dab0389d1b779c8a05b1a",
- "lib/puppet/parser/functions/is_integer.rb": "6520458000b349f1c7ba7c9ed382ae0b",
- "spec/unit/puppet/parser/functions/strip_spec.rb": "4648e46ecec2f272022f1397268b7d59",
- "lib/puppet/type/anchor.rb": "cc1da7acfe1259d5b86a64e2dea42c34",
- "spec/unit/puppet/parser/functions/getvar_spec.rb": "99880c2d16b329c872d22fe15bb05293",
- "CHANGELOG": "0c7dcc8567ac920570b91e2e8764442a",
- "lib/puppet/parser/functions/values_at.rb": "094ac110ce9f7a5b16d0c80a0cf2243c",
- "spec/unit/puppet/parser/functions/shuffle_spec.rb": "1bf72145bf39edb1c6cd83df3b0b978a",
- "lib/puppet/parser/functions/validate_hash.rb": "e9cfaca68751524efe16ecf2f958a9a0",
- "spec/unit/puppet/parser/functions/has_key_spec.rb": "3ecc38a150d685db2b766c4d91ac77b4",
- "spec/unit/puppet/parser/functions/abs_spec.rb": "7241e4f4762b1fa67408e178c7965b29",
- "spec/spec_helper.rb": "fb1c0bd01f784cd326c2945fdf201cf8",
- "lib/puppet/parser/functions/is_domain_name.rb": "4ddc0d7ff8855610660be9bf0eaf6382",
- "spec/watchr.rb": "b588ddf9ef1c19ab97aa892cc776da73",
- "lib/puppet/parser/functions/unique.rb": "217ccce6d23235af92923f50f8556963",
- "lib/puppet/parser/functions/validate_bool.rb": "4ddffdf5954b15863d18f392950b88f4",
- "lib/puppet/parser/functions/keys.rb": "eb6ac815ea14fbf423580ed903ef7bad",
- "lib/puppet/parser/functions/validate_re.rb": "57bc0a1e1cc63eb8c9da801141765db7",
- "spec/unit/puppet/parser/functions/is_string_spec.rb": "5c2387aa8b4cc98ecb5cf17df2b59137",
- "spec/unit/puppet/parser/functions/unique_spec.rb": "0822a1eda9e3bb86cb58e66effb7d14c",
- "spec/unit/puppet/parser/functions/str2bool_spec.rb": "fc3aaa818f0430d141e6dfda4a759148",
- "spec/unit/facter/root_home_spec.rb": "bed727086f867d7c15a57324c636fe67",
- "Modulefile": "558bf4531f74fc69c30284d05fa33275",
- "lib/puppet/parser/functions/reverse.rb": "1386371c0f5301055fdf99079e862b3e",
- "spec/unit/puppet/parser/functions/parsejson_spec.rb": "88b0f9b3050d72757f6c7848c9f7e14b",
- "lib/puppet/parser/functions/values.rb": "066a6e4170e5034edb9a80463dff2bb5",
- "lib/puppet/parser/functions/sort.rb": "504b033b438461ca4f9764feeb017833",
- "lib/puppet/parser/functions/is_array.rb": "875ca4356cb0d7a10606fb146b4a3d11",
- "lib/puppet/parser/functions/is_numeric.rb": "6283dd52935fb1aba41958e50c85b1ed",
- "spec/unit/puppet/parser/functions/is_array_spec.rb": "5f1698b09f52c26f7754164525cf98af",
- "lib/puppet/parser/functions/flatten.rb": "251d63696564254d41742ecbfbfcb9fd",
- "lib/puppet/parser/functions/lstrip.rb": "210b103f78622e099f91cc2956b6f741",
- "lib/puppet/parser/functions/hash.rb": "75fd86c01d5b1e50be1bc8b22d3d0a61",
- "spec/unit/puppet/parser/functions/values_at_spec.rb": "c89e10ce6e1833c08813e747f4e4f0b3",
- "spec/unit/puppet/parser/functions/sort_spec.rb": "3de167aceb5515bb183283d259065bf6",
- "spec/unit/puppet/parser/functions/join_spec.rb": "c5ef77cddae27594a042a5dec43cd5d7",
- "spec/unit/puppet/parser/functions/downcase_spec.rb": "465b4dc34a6d8b3f517fa4dfb6279999",
- "lib/puppet/parser/functions/squeeze.rb": "ae5aafb7478cced0ba0c23856e45cec5",
- "lib/puppet/parser/functions/capitalize.rb": "14481fc8c7c83fe002066ebcf6722f17",
- "RELEASE_PROCESS.markdown": "e2d2140c3719f692899f73a754175d78",
- "README.markdown": "c45c5ea68ce337f77addf217de9e8c9d",
- "spec/monkey_patches/publicize_methods.rb": "1b03a4af94f7dac35f7c2809caf372ca",
- "tests/init.pp": "1d98070412c76824e66db4b7eb74d433",
- "spec/unit/puppet/parser/functions/is_numeric_spec.rb": "b123634167033ca7d40e2416a933abf0",
- "lib/puppet/parser/functions/range.rb": "b9bab398bbaeb01b876674a8fbae9d67",
- "lib/facter/facter_dot_d.rb": "bfe4cd4cfbb9e7f57e28f932c7d76c6e",
- "lib/puppet/parser/functions/is_ip_address.rb": "a53f6e3a5855954148230846ccb3e04d",
- "lib/puppet/parser/functions/loadyaml.rb": "2b912f257aa078e376d3b3f6a86c2a00",
- "lib/puppet/parser/functions/prefix.rb": "6a2d86233c9435afc1738f60a0c34576",
- "lib/facter/root_home.rb": "20c3734960a4be1693f1bec828facba4",
- "spec/monkey_patches/alias_should_to_must.rb": "7cd4065c63f06f1ab3aaa1c5f92af947",
- "lib/puppet/parser/functions/parseyaml.rb": "6cfee471d287c8d110a3629a9ac31b69",
- "spec/unit/puppet/parser/functions/values_spec.rb": "591d6ac1a26e163f25dd88887e7a7e31",
- "lib/puppet/parser/functions/type.rb": "62f914d6c90662aaae40c5539701be60",
- "spec/unit/puppet/parser/functions/delete_at_spec.rb": "bbfdea3b0d6e8b898480095ab6250910",
- "lib/puppet/parser/functions/str2bool.rb": "846b49d623cb847c1870d7ac4a6bedf3",
- "lib/puppet/parser/functions/zip.rb": "a80782461ed9465f0cd0c010936f1855",
- "spec/unit/puppet/parser/functions/capitalize_spec.rb": "ae5454a82cf5dcd3c24de4fa43ab7ef9",
- "spec/unit/puppet/parser/functions/num2bool_spec.rb": "31df56ced10757974c2ebb68e9d7e962",
- "spec/unit/puppet/parser/functions/rstrip_spec.rb": "2e1871218bf5ed32d9c900adc044db11",
- "spec/unit/puppet/parser/functions/is_hash_spec.rb": "caafa394659af9013bf78578dca155ec",
- "tests/file_line.pp": "67727539aa7b7dd76f06626fe734f7f7",
- "spec/unit/puppet/parser/functions/strftime_spec.rb": "65f969afd72286b7687efbf5059a45fa",
- "lib/puppet/parser/functions/grep.rb": "5682995af458b05f3b53dd794c4bf896",
- "lib/puppet/type/file_line.rb": "eb3212776b27bb65d65eea36430d20c8",
- "spec/unit/puppet/parser/functions/chomp_spec.rb": "4fbc9dfb1406b4f9efde5911ca94a2fd",
- "spec/unit/puppet/parser/functions/range_spec.rb": "49df156b67467367f8bdd15a1849f6c8",
- "spec/unit/puppet/parser/functions/empty_spec.rb": "92faf7b9f3d7f7ea70cfdd4df368cea5",
- "spec/unit/puppet/parser/functions/validate_hash_spec.rb": "9d04db99b341c8e8a96a2e3594e15e09",
- "lib/puppet/parser/functions/getvar.rb": "10bf744212947bc6a7bfd2c9836dbd23",
- "lib/puppet/parser/functions/chop.rb": "4cc840d63ec172d8533a613676391d39",
- "lib/puppet/parser/functions/bool2num.rb": "8e627eee990e811e35e7e838c586bd77",
- "lib/puppet/parser/functions/validate_array.rb": "72b29289b8af1cfc3662ef9be78911b8",
- "lib/puppet/parser/functions/validate_string.rb": "6afcbc51f83f0714348b8d61e06ea7eb",
- "lib/puppet/parser/functions/time.rb": "08d88d52abd1e230e3a2f82107545d48",
- "spec/unit/puppet/parser/functions/grep_spec.rb": "ac61b94f87f28d6271e83b7fb580e82a",
- "spec/unit/puppet/parser/functions/size_spec.rb": "8bc0fe162722361e581110a9145dccc1",
- "spec/unit/puppet/parser/functions/merge_spec.rb": "169ba6a18997b25250e893e07920e5eb",
- "lib/puppet/parser/functions/delete.rb": "4a3c82d0ed8ea4c953658efdd06fe7c9",
- "spec/unit/puppet/parser/functions/reverse_spec.rb": "6b8eaec24fe50ad337f16c9e1869dbe2",
- "spec/unit/puppet/parser/functions/parseyaml_spec.rb": "c5e1b52e9cca526bd67c1d05507f03de",
- "spec/unit/puppet/parser/functions/is_ip_address_spec.rb": "f07dff16f07bc66aeff3dbd159e628bb",
- "lib/puppet/parser/functions/member.rb": "541e67d06bc4155e79b00843a125e9bc",
- "spec/lib/puppet_spec/verbose.rb": "2e0e0e74f2c5ec0408d455e773755bf9",
- "spec/unit/puppet/parser/functions/flatten_spec.rb": "ba9feb890d222cbb3cdbe44f60fc34a5",
- "lib/puppet/parser/functions/parsejson.rb": "e7f968c34928107b84cd0860daf50ab1",
- "lib/puppet/parser/functions/is_float.rb": "491937483b14fbe2594a6e0e9af6acf9",
- "lib/puppet/parser/functions/rstrip.rb": "8a0d69876bdbc88a2054ba41c9c38961",
- "spec/unit/puppet/parser/functions/lstrip_spec.rb": "77087828a0d1ae7ad2131019868a7d9b",
- "lib/puppet/parser/functions/num2bool.rb": "dbdc81982468ebb8ac24ab78d7097ad3",
- "spec/unit/puppet/parser/functions/is_float_spec.rb": "72202b9e106f0d7ddc4feb055e4d6ee4",
- "spec/unit/puppet/parser/functions/zip_spec.rb": "5668bb74eba13a03c5ccbab85698502a",
- "lib/puppet/parser/functions/join.rb": "b28087823456ca5cf943de4a233ac77f",
- "spec/unit/puppet/type/file_line_spec.rb": "d91574136b6078f78a00ecc48f1e5655",
- "spec/unit/puppet/parser/functions/validate_bool_spec.rb": "7de673f1da799e5cf4ce4203eac18a93",
- "Rakefile": "1783f110354faf65bae54d394b639671",
- "spec/unit/puppet/type/anchor_spec.rb": "a5478a72a7fab2d215f39982a9230c18",
- "spec/unit/puppet/parser/functions/chop_spec.rb": "53430bd3884404952f3f7f634dfb743a",
- "spec/unit/puppet/parser/functions/time_spec.rb": "9f0c4e73088ee2db967ce6f4291e60f5",
- "lib/puppet/parser/functions/strip.rb": "273d547c7b05c0598556464dfd12f5fd",
- "manifests/init.pp": "f2ba5f36e7227ed87bbb69034fc0de8b",
- "spec/lib/puppet_spec/files.rb": "34e40f4dcdc90d1138a471d883c33d79",
- "spec/unit/puppet/parser/functions/is_integer_spec.rb": "6d648bbaeac166babe835f1cec23070a",
- "spec/lib/puppet_spec/fixtures.rb": "147446d18612c8395ac65be10b1cd9ab",
- "spec/unit/puppet/parser/functions/delete_spec.rb": "7d6fa7f049f75b4b356ee3e6b1ad8d7a",
- "lib/puppet/parser/functions/is_string.rb": "2bd9a652bbb2668323eee6c57729ff64",
- "spec/unit/puppet/parser/functions/keys_spec.rb": "4d548018ab0a1e329285db8af92ae6a7",
- "lib/puppet/parser/functions/shuffle.rb": "6445e6b4dc62c37b184a60eeaf34414b",
- "spec/unit/puppet/parser/functions/bool2num_spec.rb": "7d465ea336aebb06d7aaff10862bb1bf",
- "lib/puppet/parser/functions/downcase.rb": "9204a04c2a168375a38d502db8811bbe",
- "LICENSE": "38a048b9d82e713d4e1b2573e370a756",
- "spec/unit/puppet/parser/functions/is_domain_name_spec.rb": "a6b6bee60461a0fe51bb18e867db2337",
- "lib/puppet/parser/functions/chomp.rb": "7040b3348d2f770f265cf4c8c25c51c5",
- "lib/puppet/parser/functions/size.rb": "8972d48c0f9e487d659bd7326b40b642",
- "manifests/stages.pp": "cc6ed1751d334b0ea278c0335c7f0b5a",
- "spec/unit/puppet/parser/functions/validate_array_spec.rb": "9ff22cd8e660e244abac8993fc45037b",
- "spec/spec.opts": "a600ded995d948e393fbe2320ba8e51c",
- "lib/puppet/parser/functions/merge.rb": "52281fe881b762e2adfef20f58dc4180",
- "lib/puppet/parser/functions/has_key.rb": "7cd9728c38f0b0065f832dabd62b0e7e",
- "lib/puppet/parser/functions/empty.rb": "ae92905c9d94ddca30bf56b7b1dabedf",
- "spec/unit/puppet/parser/functions/upcase_spec.rb": "aad3aa16fc8b930ca5fa53781f18be89",
- "lib/puppet/provider/file_line/ruby.rb": "069761f23f95c078821024da9d916db4",
- "spec/unit/puppet/parser/functions/validate_string_spec.rb": "2886898011792249e80837c6791639ba"
- },
- "author": "puppetlabs",
- "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
- "name": "puppetlabs-stdlib",
- "license": "Apache 2.0"
-}
\ No newline at end of file
+++ /dev/null
-require 'fileutils'
-require 'tempfile'
-
-# A support module for testing files.
-module PuppetSpec::Files
- # This code exists only to support tests that run as root, pretty much.
- # Once they have finally been eliminated this can all go... --daniel 2011-04-08
- if Puppet.features.posix? then
- def self.in_tmp(path)
- path =~ /^\/tmp/ or path =~ /^\/var\/folders/
- end
- elsif Puppet.features.microsoft_windows?
- def self.in_tmp(path)
- tempdir = File.expand_path(File.join(Dir::LOCAL_APPDATA, "Temp"))
- path =~ /^#{tempdir}/
- end
- else
- fail "Help! Can't find in_tmp for this platform"
- end
-
- def self.cleanup
- $global_tempfiles ||= []
- while path = $global_tempfiles.pop do
- fail "Not deleting tmpfile #{path} outside regular tmpdir" unless in_tmp(path)
-
- begin
- FileUtils.rm_r path, :secure => true
- rescue Errno::ENOENT
- # nothing to do
- end
- end
- end
-
- def tmpfile(name)
- # Generate a temporary file, just for the name...
- source = Tempfile.new(name)
- path = source.path
- source.close!
-
- # ...record it for cleanup,
- $global_tempfiles ||= []
- $global_tempfiles << File.expand_path(path)
-
- # ...and bam.
- path
- end
-
- def tmpdir(name)
- path = tmpfile(name)
- FileUtils.mkdir_p(path)
- path
- end
-end
+++ /dev/null
-module PuppetSpec::Fixtures
- def fixtures(*rest)
- File.join(PuppetSpec::FIXTURE_DIR, *rest)
- end
- def my_fixture_dir
- callers = caller
- while line = callers.shift do
- next unless found = line.match(%r{/spec/(.*)_spec\.rb:})
- return fixtures(found[1])
- end
- fail "sorry, I couldn't work out your path from the caller stack!"
- end
- def my_fixture(name)
- file = File.join(my_fixture_dir, name)
- unless File.readable? file then
- fail Puppet::DevError, "fixture '#{name}' for #{my_fixture_dir} is not readable"
- end
- return file
- end
- def my_fixtures(glob = '*', flags = 0)
- files = Dir.glob(File.join(my_fixture_dir, glob), flags)
- unless files.length > 0 then
- fail Puppet::DevError, "fixture '#{glob}' for #{my_fixture_dir} had no files!"
- end
- block_given? and files.each do |file| yield file end
- files
- end
-end
+++ /dev/null
-require 'stringio'
-
-########################################################################
-# Backward compatibility for Jenkins outdated environment.
-module RSpec
- module Matchers
- module BlockAliases
- alias_method :to, :should unless method_defined? :to
- alias_method :to_not, :should_not unless method_defined? :to_not
- alias_method :not_to, :should_not unless method_defined? :not_to
- end
- end
-end
-
-
-########################################################################
-# Custom matchers...
-RSpec::Matchers.define :have_matching_element do |expected|
- match do |actual|
- actual.any? { |item| item =~ expected }
- end
-end
-
-
-RSpec::Matchers.define :exit_with do |expected|
- actual = nil
- match do |block|
- begin
- block.call
- rescue SystemExit => e
- actual = e.status
- end
- actual and actual == expected
- end
- failure_message_for_should do |block|
- "expected exit with code #{expected} but " +
- (actual.nil? ? " exit was not called" : "we exited with #{actual} instead")
- end
- failure_message_for_should_not do |block|
- "expected that exit would not be called with #{expected}"
- end
- description do
- "expect exit with #{expected}"
- end
-end
-
-
-RSpec::Matchers.define :have_printed do |expected|
- match do |block|
- $stderr = $stdout = StringIO.new
-
- begin
- block.call
- ensure
- $stdout.rewind
- @actual = $stdout.read
-
- $stdout = STDOUT
- $stderr = STDERR
- end
-
- if @actual then
- case expected
- when String
- @actual.include? expected
- when Regexp
- expected.match @actual
- else
- raise ArgumentError, "No idea how to match a #{@actual.class.name}"
- end
- end
- end
-
- failure_message_for_should do |actual|
- if actual.nil? then
- "expected #{expected.inspect}, but nothing was printed"
- else
- "expected #{expected.inspect} to be printed; got:\n#{actual}"
- end
- end
-
- description do
- "expect #{expected.inspect} to be printed"
- end
-
- diffable
-end
+++ /dev/null
-# Support code for running stuff with warnings disabled.
-module Kernel
- def with_verbose_disabled
- verbose, $VERBOSE = $VERBOSE, nil
- result = yield
- $VERBOSE = verbose
- return result
- end
-end
+++ /dev/null
-require 'rspec'
-
-class Object
- # This is necessary because the RAL has a 'should'
- # method.
- alias :must :should
- alias :must_not :should_not
-end
+++ /dev/null
-# Some monkey-patching to allow us to test private methods.
-class Class
- def publicize_methods(*methods)
- saved_private_instance_methods = methods.empty? ? self.private_instance_methods : methods
-
- self.class_eval { public(*saved_private_instance_methods) }
- yield
- self.class_eval { private(*saved_private_instance_methods) }
- end
-end
-
+++ /dev/null
---format
-s
---colour
---loadby
-mtime
---backtrace
+++ /dev/null
-dir = File.expand_path(File.dirname(__FILE__))
-$LOAD_PATH.unshift File.join(dir, 'lib')
-
-p dir
-
-# Don't want puppet getting the command line arguments for rake or autotest
-ARGV.clear
-
-require 'puppet'
-require 'facter'
-require 'mocha'
-gem 'rspec', '>=2.0.0'
-require 'rspec/expectations'
-
-# So everyone else doesn't have to include this base constant.
-module PuppetSpec
- FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
-end
-
-require 'pathname'
-require 'tmpdir'
-
-require 'puppet_spec/verbose'
-require 'puppet_spec/files'
-require 'puppet_spec/fixtures'
-require 'puppet_spec/matchers'
-require 'monkey_patches/alias_should_to_must'
-require 'monkey_patches/publicize_methods'
-
-# JJM Hack to make the stdlib tests run in Puppet 2.6 (See puppet commit cf183534)
-if not Puppet.constants.include? "Test" then
- module Puppet::Test
- class LogCollector
- def initialize(logs)
- @logs = logs
- end
-
- def <<(value)
- @logs << value
- end
- end
- end
- Puppet::Util::Log.newdesttype :log_collector do
- match "Puppet::Test::LogCollector"
-
- def initialize(messages)
- @messages = messages
- end
-
- def handle(msg)
- @messages << msg
- end
- end
-end
-
-Pathname.glob("#{dir}/shared_behaviours/**/*.rb") do |behaviour|
- require behaviour.relative_path_from(Pathname.new(dir))
-end
-
-RSpec.configure do |config|
- include PuppetSpec::Fixtures
-
- config.mock_with :mocha
-
- config.before :each do
- GC.disable
-
- # these globals are set by Application
- $puppet_application_mode = nil
- $puppet_application_name = nil
-
- # REVISIT: I think this conceals other bad tests, but I don't have time to
- # fully diagnose those right now. When you read this, please come tell me
- # I suck for letting this float. --daniel 2011-04-21
- Signal.stubs(:trap)
-
- # Set the confdir and vardir to gibberish so that tests
- # have to be correctly mocked.
- Puppet[:confdir] = "/dev/null"
- Puppet[:vardir] = "/dev/null"
-
- # Avoid opening ports to the outside world
- Puppet.settings[:bindaddress] = "127.0.0.1"
-
- @logs = []
- Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(@logs))
-
- @log_level = Puppet::Util::Log.level
- end
-
- config.after :each do
- Puppet.settings.clear
- Puppet::Node::Environment.clear
- Puppet::Util::Storage.clear
- Puppet::Util::ExecutionStub.reset if Puppet::Util.constants.include? "ExecutionStub"
-
- PuppetSpec::Files.cleanup
-
- @logs.clear
- Puppet::Util::Log.close_all
- Puppet::Util::Log.level = @log_level
-
- GC.enable
- end
-end
+++ /dev/null
-require 'spec_helper'
-require 'facter/root_home'
-
-describe Facter::Util::RootHome do
- context "solaris" do
- let(:root_ent) { "root:x:0:0:Super-User:/:/sbin/sh" }
- let(:expected_root_home) { "/" }
-
- it "should return /" do
- Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
- Facter::Util::RootHome.get_root_home.should == expected_root_home
- end
- end
- context "linux" do
- let(:root_ent) { "root:x:0:0:root:/root:/bin/bash" }
- let(:expected_root_home) { "/root" }
-
- it "should return /root" do
- Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
- Facter::Util::RootHome.get_root_home.should == expected_root_home
- end
- end
- context "macosx" do
- let(:root_ent) { "root:*:0:0:System Administrator:/var/root:/bin/sh" }
- let(:expected_root_home) { "/var/root" }
-
- it "should return /var/root" do
- Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
- Facter::Util::RootHome.get_root_home.should == expected_root_home
- end
- end
- context "windows" do
- let(:root_ent) { "FIXME TBD on Windows" }
- let(:expected_root_home) { "FIXME TBD on Windows" }
-
- it "should return FIXME TBD on windows" do
- pending "FIXME: TBD on windows"
- Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
- Facter::Util::RootHome.get_root_home.should == expected_root_home
- end
- end
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the abs function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("abs").should == "function_abs"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_abs([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should convert a negative number into a positive" do
- result = @scope.function_abs(["-34"])
- result.should(eq(34))
- end
-
- it "should do nothing with a positive number" do
- result = @scope.function_abs(["5678"])
- result.should(eq(5678))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the bool2num function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("bool2num").should == "function_bool2num"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_bool2num([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should convert true to 1" do
- result = @scope.function_bool2num([true])
- result.should(eq(1))
- end
-
- it "should convert false to 0" do
- result = @scope.function_bool2num([false])
- result.should(eq(0))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the capitalize function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("capitalize").should == "function_capitalize"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_capitalize([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should capitalize the beginning of a string" do
- result = @scope.function_capitalize(["abc"])
- result.should(eq("Abc"))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the chomp function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("chomp").should == "function_chomp"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_chomp([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should chomp the end of a string" do
- result = @scope.function_chomp(["abc\n"])
- result.should(eq("abc"))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the chop function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("chop").should == "function_chop"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_chop([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should chop the end of a string" do
- result = @scope.function_chop(["asdf\n"])
- result.should(eq("asdf"))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the delete_at function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("delete_at").should == "function_delete_at"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_delete_at([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should delete an item at specified location from an array" do
- result = @scope.function_delete_at([['a','b','c'],1])
- result.should(eq(['a','c']))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the delete function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("delete").should == "function_delete"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_delete([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should delete an item from an array" do
- result = @scope.function_delete([['a','b','c'],'b'])
- result.should(eq(['a','c']))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the downcase function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("downcase").should == "function_downcase"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_downcase([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should downcase a string" do
- result = @scope.function_downcase(["ASFD"])
- result.should(eq("asfd"))
- end
-
- it "should do nothing to a string that is already downcase" do
- result = @scope.function_downcase(["asdf asdf"])
- result.should(eq("asdf asdf"))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the empty function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("empty").should == "function_empty"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_empty([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return a true for an empty string" do
- result = @scope.function_empty([''])
- result.should(eq(true))
- end
-
- it "should return a false for a non-empty string" do
- result = @scope.function_empty(['asdf'])
- result.should(eq(false))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the flatten function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("flatten").should == "function_flatten"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_flatten([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should flatten a complex data structure" do
- result = @scope.function_flatten([["a","b",["c",["d","e"],"f","g"]]])
- result.should(eq(["a","b","c","d","e","f","g"]))
- end
-
- it "should do nothing to a structure that is already flat" do
- result = @scope.function_flatten([["a","b","c","d"]])
- result.should(eq(["a","b","c","d"]))
- end
-
-end
+++ /dev/null
-require 'puppet'
-
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
-
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
-describe Puppet::Parser::Functions.function(:getvar) do
-
- # Pulled from Dan's create_resources function
- def get_scope
- @topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- @topscope.parent = nil
- @scope = Puppet::Parser::Scope.new
- @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- @scope.parent = @topscope
- @compiler = @scope.compiler
- end
-
- describe 'when calling getvar from puppet' do
-
- it "should not compile when no arguments are passed" do
- Puppet[:code] = 'getvar()'
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
- end
- it "should not compile when too many arguments are passed" do
- Puppet[:code] = 'getvar("foo::bar", "baz")'
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
- end
-
- it "should lookup variables in other namespaces" do
- pending "Puppet doesn't appear to think getvar is an rvalue function... BUG?"
- Puppet[:code] = <<-'ENDofPUPPETcode'
- class site::data { $foo = 'baz' }
- include site::data
- $foo = getvar("site::data::foo")
- if $foo != 'baz' {
- fail('getvar did not return what we expect')
- }
- ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
- end
-
- end
-
-end
-
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the grep function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("grep").should == "function_grep"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_grep([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should grep contents from an array" do
- result = @scope.function_grep([["aaabbb","bbbccc","dddeee"], "bbb"])
- result.should(eq(["aaabbb","bbbccc"]))
- end
-
-end
+++ /dev/null
-require 'puppet'
-require 'mocha'
-describe Puppet::Parser::Functions.function(:has_key) do
-
- # Pulled from Dan's create_resources function
- # TODO - this should be moved to spec_helper since the
- # logic is likely to be applied to multiple rspec files.
- let(:compiler) {
- topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- topscope.parent = nil
- my_scope = Puppet::Parser::Scope.new
- my_scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- my_scope.parent = topscope
- compiler = my_scope.compiler
- }
- let(:scope) {
- scope = Puppet::Parser::Scope.new
- scope.stubs(:environment).returns(Puppet::Node::Environment.new('production'))
- scope
- }
-
- describe 'when calling has_key from puppet' do
- it "should not compile when no arguments are passed" do
- Puppet[:code] = 'has_key()'
- expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
- end
- it "should not compile when 1 argument is passed" do
- Puppet[:code] = "has_key('foo')"
- expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
- end
- it "should require the first value to be a Hash" do
- Puppet[:code] = "has_key('foo', 'bar')"
- expect { compiler.compile }.should raise_error(Puppet::ParseError, /expects the first argument to be a hash/)
- end
- end
- describe 'when calling the function has_key from a scope instance' do
- it 'should detect existing keys' do
- scope.function_has_key([{'one' => 1}, 'one']).should be_true
- end
- it 'should detect existing keys' do
- scope.function_has_key([{'one' => 1}, 'two']).should be_false
- end
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the hash function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("hash").should == "function_hash"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_hash([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should convert an array to a hash" do
- result = @scope.function_hash([['a',1,'b',2,'c',3]])
- result.should(eq({'a'=>1,'b'=>2,'c'=>3}))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the is_array function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("is_array").should == "function_is_array"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_array([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return true if passed an array" do
- result = @scope.function_is_array([[1,2,3]])
- result.should(eq(true))
- end
-
- it "should return false if passed a hash" do
- result = @scope.function_is_array([{'a'=>1}])
- result.should(eq(false))
- end
-
- it "should return false if passed a string" do
- result = @scope.function_is_array(["asdf"])
- result.should(eq(false))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the is_domain_name function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("is_domain_name").should == "function_is_domain_name"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_domain_name([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return true if a valid domain name" do
- result = @scope.function_is_domain_name(["foo.bar.com"])
- result.should(be_true)
- end
-
- it "should allow domain parts to start with numbers" do
- result = @scope.function_is_domain_name(["3foo.2bar.com"])
- result.should(be_true)
- end
-
- it "should allow domain to end with a dot" do
- result = @scope.function_is_domain_name(["3foo.2bar.com."])
- result.should(be_true)
- end
-
- it "should allow a single part domain" do
- result = @scope.function_is_domain_name(["orange"])
- result.should(be_true)
- end
-
- it "should return false if domain parts start with hyphens" do
- result = @scope.function_is_domain_name(["-3foo.2bar.com"])
- result.should(be_false)
- end
-
- it "should return true if domain contains hyphens" do
- result = @scope.function_is_domain_name(["3foo-bar.2bar-fuzz.com"])
- result.should(be_true)
- end
-
- it "should return false if domain name contains spaces" do
- result = @scope.function_is_domain_name(["not valid"])
- result.should(be_false)
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the is_float function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("is_float").should == "function_is_float"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_float([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return true if a float" do
- result = @scope.function_is_float(["0.12"])
- result.should(eq(true))
- end
-
- it "should return false if a string" do
- result = @scope.function_is_float(["asdf"])
- result.should(eq(false))
- end
-
- it "should return false if an integer" do
- result = @scope.function_is_float(["3"])
- result.should(eq(false))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the is_hash function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("is_hash").should == "function_is_hash"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_hash([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return true if passed a hash" do
- result = @scope.function_is_hash([{"a"=>1,"b"=>2}])
- result.should(eq(true))
- end
-
- it "should return false if passed an array" do
- result = @scope.function_is_hash([["a","b"]])
- result.should(eq(false))
- end
-
- it "should return false if passed a string" do
- result = @scope.function_is_hash(["asdf"])
- result.should(eq(false))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the is_integer function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("is_integer").should == "function_is_integer"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_integer([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return true if an integer" do
- result = @scope.function_is_integer(["3"])
- result.should(eq(true))
- end
-
- it "should return false if a float" do
- result = @scope.function_is_integer(["3.2"])
- result.should(eq(false))
- end
-
- it "should return false if a string" do
- result = @scope.function_is_integer(["asdf"])
- result.should(eq(false))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the is_ip_address function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("is_ip_address").should == "function_is_ip_address"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_ip_address([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return true if an IPv4 address" do
- result = @scope.function_is_ip_address(["1.2.3.4"])
- result.should(eq(true))
- end
-
- it "should return true if a full IPv6 address" do
- result = @scope.function_is_ip_address(["fe80:0000:cd12:d123:e2f8:47ff:fe09:dd74"])
- result.should(eq(true))
- end
-
- it "should return true if a compressed IPv6 address" do
- result = @scope.function_is_ip_address(["fe00::1"])
- result.should(eq(true))
- end
-
- it "should return false if not valid" do
- result = @scope.function_is_ip_address(["asdf"])
- result.should(eq(false))
- end
-
- it "should return false if IP octets out of range" do
- result = @scope.function_is_ip_address(["1.1.1.300"])
- result.should(eq(false))
- end
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the is_mac_address function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("is_mac_address").should == "function_is_mac_address"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_mac_address([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return true if a valid mac address" do
- result = @scope.function_is_mac_address(["00:a0:1f:12:7f:a0"])
- result.should(eq(true))
- end
-
- it "should return false if octets are out of range" do
- result = @scope.function_is_mac_address(["00:a0:1f:12:7f:g0"])
- result.should(eq(false))
- end
-
- it "should return false if not valid" do
- result = @scope.function_is_mac_address(["not valid"])
- result.should(eq(false))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the is_numeric function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("is_numeric").should == "function_is_numeric"
- end
-
- it "should raise a ParseError if there is less than 1 argument" do
- lambda { @scope.function_is_numeric([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return true if an integer" do
- result = @scope.function_is_numeric(["3"])
- result.should(eq(true))
- end
-
- it "should return true if a float" do
- result = @scope.function_is_numeric(["3.2"])
- result.should(eq(true))
- end
-
- it "should return false if a string" do
- result = @scope.function_is_numeric(["asdf"])
- result.should(eq(false))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the is_string function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("is_string").should == "function_is_string"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_is_string([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return true if a string" do
- result = @scope.function_is_string(["asdf"])
- result.should(eq(true))
- end
-
- it "should return false if an integer" do
- result = @scope.function_is_string(["3"])
- result.should(eq(false))
- end
-
- it "should return false if a float" do
- result = @scope.function_is_string(["3.23"])
- result.should(eq(false))
- end
-
- it "should return false if an array" do
- result = @scope.function_is_string([["a","b","c"]])
- result.should(eq(false))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the join function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("join").should == "function_join"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_join([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should join an array into a string" do
- result = @scope.function_join([["a","b","c"], ":"])
- result.should(eq("a:b:c"))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the keys function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("keys").should == "function_keys"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_keys([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return an array of keys when given a hash" do
- result = @scope.function_keys([{'a'=>1, 'b' => 2}])
- result.should(eq(['a','b']))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the lstrip function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("lstrip").should == "function_lstrip"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_lstrip([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should lstrip a string" do
- result = @scope.function_lstrip([" asdf"])
- result.should(eq('asdf'))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the member function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("member").should == "function_member"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_member([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return true if a member is in an array" do
- result = @scope.function_member([["a","b","c"], "a"])
- result.should(eq(true))
- end
-
- it "should return false if a member is not in an array" do
- result = @scope.function_member([["a","b","c"], "d"])
- result.should(eq(false))
- end
-
-end
+++ /dev/null
-require 'puppet'
-require 'mocha'
-describe Puppet::Parser::Functions.function(:merge) do
-
- # Pulled from Dan's create_resources function
- # TODO - these let statements should be moved somewhere
- # where they can be resued
- let(:compiler) {
- topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- topscope.parent = nil
- my_scope = Puppet::Parser::Scope.new
- my_scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- my_scope.parent = topscope
- compiler = my_scope.compiler
- }
- let(:scope) {
- scope = Puppet::Parser::Scope.new
- scope.stubs(:environment).returns(Puppet::Node::Environment.new('production'))
- scope
- }
-
- describe 'when calling merge from puppet' do
- it "should not compile when no arguments are passed" do
- Puppet[:code] = 'merge()'
- expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
- end
- it "should not compile when 1 argument is passed" do
- Puppet[:code] = "$my_hash={'one' => 1}\nmerge($my_hash)"
- expect { compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
- end
- end
- describe 'when calling merge on the scope instance' do
- it 'should require all parameters are hashes' do
- expect { new_hash = scope.function_merge([{}, '2'])}.should raise_error(Puppet::ParseError, /unexpected argument type String/)
-
- end
- it 'should be able to merge two hashes' do
- new_hash = scope.function_merge([{'one' => '1', 'two' => '1'}, {'two' => '2', 'three' => '2'}])
- new_hash['one'].should == '1'
- new_hash['two'].should == '2'
- new_hash['three'].should == '2'
- end
- it 'should merge multiple hashes' do
- hash = scope.function_merge([{'one' => 1}, {'one' => '2'}, {'one' => '3'}])
- hash['one'].should == '3'
- end
- it 'should accept empty hashes' do
- scope.function_merge([{},{},{}]).should == {}
- end
-
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the num2bool function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("num2bool").should == "function_num2bool"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return true if 1" do
- result = @scope.function_num2bool(["1"])
- result.should(be_true)
- end
-
- it "should return false if 0" do
- result = @scope.function_num2bool(["0"])
- result.should(be_false)
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the parsejson function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("parsejson").should == "function_parsejson"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_parsejson([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should convert JSON to a data structure" do
- json = <<-EOS
-["aaa","bbb","ccc"]
-EOS
- result = @scope.function_parsejson([json])
- result.should(eq(['aaa','bbb','ccc']))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the parseyaml function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("parseyaml").should == "function_parseyaml"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_parseyaml([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should convert YAML to a data structure" do
- yaml = <<-EOS
-- aaa
-- bbb
-- ccc
-EOS
- result = @scope.function_parseyaml([yaml])
- result.should(eq(['aaa','bbb','ccc']))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the prefix function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("prefix").should == "function_prefix"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_prefix([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return a prefixed array" do
- result = @scope.function_prefix([['a','b','c'], 'p'])
- result.should(eq(['pa','pb','pc']))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the range function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("range").should == "function_range"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_range([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return a letter range" do
- result = @scope.function_range(["a","d"])
- result.should(eq(['a','b','c','d']))
- end
-
- it "should return a number range" do
- result = @scope.function_range(["1","4"])
- result.should(eq([1,2,3,4]))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the reverse function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("reverse").should == "function_reverse"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_reverse([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should reverse a string" do
- result = @scope.function_reverse(["asdfghijkl"])
- result.should(eq('lkjihgfdsa'))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the rstrip function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("rstrip").should == "function_rstrip"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_rstrip([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should rstrip a string" do
- result = @scope.function_rstrip(["asdf "])
- result.should(eq('asdf'))
- end
-
- it "should rstrip each element in an array" do
- result = @scope.function_rstrip([["a ","b ", "c "]])
- result.should(eq(['a','b','c']))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the shuffle function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("shuffle").should == "function_shuffle"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_shuffle([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should shuffle a string and the result should be the same size" do
- result = @scope.function_shuffle(["asdf"])
- result.size.should(eq(4))
- end
-
- it "should shuffle a string but the sorted contents should still be the same" do
- result = @scope.function_shuffle(["adfs"])
- result.split("").sort.join("").should(eq("adfs"))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the size function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("size").should == "function_size"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_size([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return the size of a string" do
- result = @scope.function_size(["asdf"])
- result.should(eq(4))
- end
-
- it "should return the size of an array" do
- result = @scope.function_size([["a","b","c"]])
- result.should(eq(3))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the sort function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("sort").should == "function_sort"
- end
-
- it "should raise a ParseError if there is not 1 arguments" do
- lambda { @scope.function_sort(['','']) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should sort an array" do
- result = @scope.function_sort([["a","c","b"]])
- result.should(eq(['a','b','c']))
- end
-
- it "should sort a string" do
- result = @scope.function_sort(["acb"])
- result.should(eq('abc'))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the squeeze function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("squeeze").should == "function_squeeze"
- end
-
- it "should raise a ParseError if there is less than 2 arguments" do
- lambda { @scope.function_squeeze([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should squeeze a string" do
- result = @scope.function_squeeze(["aaabbbbcccc"])
- result.should(eq('abc'))
- end
-
- it "should squeeze all elements in an array" do
- result = @scope.function_squeeze([["aaabbbbcccc","dddfff"]])
- result.should(eq(['abc','df']))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the str2bool function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("str2bool").should == "function_str2bool"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_str2bool([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should convert string 'true' to true" do
- result = @scope.function_str2bool(["true"])
- result.should(eq(true))
- end
-
- it "should convert string 'undef' to false" do
- result = @scope.function_str2bool(["undef"])
- result.should(eq(false))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the strftime function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("strftime").should == "function_strftime"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_strftime([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "using %s should be higher then when I wrote this test" do
- result = @scope.function_strftime(["%s"])
- result.to_i.should(be > 1311953157)
- end
-
- it "using %s should be lower then 1.5 trillion" do
- result = @scope.function_strftime(["%s"])
- result.to_i.should(be < 1500000000)
- end
-
- it "should return a date when given %Y-%m-%d" do
- result = @scope.function_strftime(["%Y-%m-%d"])
- result.should =~ /^\d{4}-\d{2}-\d{2}$/
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the strip function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("strip").should == "function_strip"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_strip([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should strip a string" do
- result = @scope.function_strip([" ab cd "])
- result.should(eq('ab cd'))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the swapcase function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("swapcase").should == "function_swapcase"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_swapcase([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should swapcase a string" do
- result = @scope.function_swapcase(["aaBBccDD"])
- result.should(eq('AAbbCCdd'))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the time function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("time").should == "function_time"
- end
-
- it "should raise a ParseError if there is more than 2 arguments" do
- lambda { @scope.function_time(['','']) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return a number" do
- result = @scope.function_time([])
- result.class.should(eq(Fixnum))
- end
-
- it "should be higher then when I wrote this test" do
- result = @scope.function_time([])
- result.should(be > 1311953157)
- end
-
- it "should be lower then 1.5 trillion" do
- result = @scope.function_time([])
- result.should(be < 1500000000)
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the type function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("type").should == "function_type"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_type([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return string when given a string" do
- result = @scope.function_type(["aaabbbbcccc"])
- result.should(eq('string'))
- end
-
- it "should return array when given an array" do
- result = @scope.function_type([["aaabbbbcccc","asdf"]])
- result.should(eq('array'))
- end
-
- it "should return hash when given a hash" do
- result = @scope.function_type([{"a"=>1,"b"=>2}])
- result.should(eq('hash'))
- end
-
- it "should return integer when given an integer" do
- result = @scope.function_type(["1"])
- result.should(eq('integer'))
- end
-
- it "should return float when given a float" do
- result = @scope.function_type(["1.34"])
- result.should(eq('float'))
- end
-
- it "should return boolean when given a boolean" do
- result = @scope.function_type([true])
- result.should(eq('boolean'))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the unique function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("unique").should == "function_unique"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_unique([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should remove duplicate elements in a string" do
- result = @scope.function_unique(["aabbc"])
- result.should(eq('abc'))
- end
-
- it "should remove duplicate elements in an array" do
- result = @scope.function_unique([["a","a","b","b","c"]])
- result.should(eq(['a','b','c']))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the upcase function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("upcase").should == "function_upcase"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_upcase([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should upcase a string" do
- result = @scope.function_upcase(["abc"])
- result.should(eq('ABC'))
- end
-
- it "should do nothing if a string is already upcase" do
- result = @scope.function_upcase(["ABC"])
- result.should(eq('ABC'))
- end
-
-end
+++ /dev/null
-require 'puppet'
-
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
-
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
-describe Puppet::Parser::Functions.function(:validate_array) do
-
- # Pulled from Dan's create_resources function
- def get_scope
- @topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- @topscope.parent = nil
- @scope = Puppet::Parser::Scope.new
- @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- @scope.parent = @topscope
- @compiler = @scope.compiler
- end
-
- describe 'when calling validate_array from puppet' do
-
- %w{ true false }.each do |the_string|
-
- it "should not compile when #{the_string} is a string" do
- Puppet[:code] = "validate_array('#{the_string}')"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
- end
-
- it "should not compile when #{the_string} is a bare word" do
- Puppet[:code] = "validate_array(#{the_string})"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
- end
-
- end
-
- it "should compile when multiple array arguments are passed" do
- Puppet[:code] = <<-'ENDofPUPPETcode'
- $foo = [ ]
- $bar = [ 'one', 'two' ]
- validate_array($foo, $bar)
- ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
- end
-
- it "should not compile when an undef variable is passed" do
- Puppet[:code] = <<-'ENDofPUPPETcode'
- $foo = undef
- validate_array($foo)
- ENDofPUPPETcode
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not an Array/)
- end
-
- end
-
-end
-
+++ /dev/null
-require 'puppet'
-
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
-
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
-describe Puppet::Parser::Functions.function(:validate_bool) do
-
- # Pulled from Dan's create_resources function
- def get_scope
- @topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- @topscope.parent = nil
- @scope = Puppet::Parser::Scope.new
- @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- @scope.parent = @topscope
- @compiler = @scope.compiler
- end
-
- describe 'when calling validate_bool from puppet' do
-
- %w{ true false }.each do |the_string|
-
- it "should not compile when #{the_string} is a string" do
- Puppet[:code] = "validate_bool('#{the_string}')"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
- end
-
- it "should compile when #{the_string} is a bare word" do
- Puppet[:code] = "validate_bool(#{the_string})"
- get_scope
- @scope.compiler.compile
- end
-
- end
-
- it "should not compile when an arbitrary string is passed" do
- Puppet[:code] = 'validate_bool("jeff and dan are awesome")'
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
- end
-
- it "should not compile when no arguments are passed" do
- Puppet[:code] = 'validate_bool()'
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /wrong number of arguments/)
- end
-
- it "should compile when multiple boolean arguments are passed" do
- Puppet[:code] = <<-'ENDofPUPPETcode'
- $foo = true
- $bar = false
- validate_bool($foo, $bar, true, false)
- ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
- end
-
- it "should compile when multiple boolean arguments are passed" do
- Puppet[:code] = <<-'ENDofPUPPETcode'
- $foo = true
- $bar = false
- validate_bool($foo, $bar, true, false, 'jeff')
- ENDofPUPPETcode
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a boolean/)
- end
-
- end
-
-end
-
+++ /dev/null
-require 'puppet'
-
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
-
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
-describe Puppet::Parser::Functions.function(:validate_hash) do
-
- # Pulled from Dan's create_resources function
- def get_scope
- @topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- @topscope.parent = nil
- @scope = Puppet::Parser::Scope.new
- @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- @scope.parent = @topscope
- @compiler = @scope.compiler
- end
-
- describe 'when calling validate_hash from puppet' do
-
- %w{ true false }.each do |the_string|
-
- it "should not compile when #{the_string} is a string" do
- Puppet[:code] = "validate_hash('#{the_string}')"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
- end
-
- it "should not compile when #{the_string} is a bare word" do
- Puppet[:code] = "validate_hash(#{the_string})"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
- end
-
- end
-
- it "should compile when multiple hash arguments are passed" do
- Puppet[:code] = <<-'ENDofPUPPETcode'
- $foo = {}
- $bar = { 'one' => 'two' }
- validate_hash($foo, $bar)
- ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
- end
-
- it "should not compile when an undef variable is passed" do
- Puppet[:code] = <<-'ENDofPUPPETcode'
- $foo = undef
- validate_hash($foo)
- ENDofPUPPETcode
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a Hash/)
- end
-
- end
-
-end
-
+++ /dev/null
-require 'puppet'
-
-# We don't need this for the basic tests we're doing
-# require 'spec_helper'
-
-# Dan mentioned that Nick recommended the function method call
-# to return the string value for the test description.
-# this will not even try the test if the function cannot be
-# loaded.
-describe Puppet::Parser::Functions.function(:validate_string) do
-
- # Pulled from Dan's create_resources function
- def get_scope
- @topscope = Puppet::Parser::Scope.new
- # This is necessary so we don't try to use the compiler to discover our parent.
- @topscope.parent = nil
- @scope = Puppet::Parser::Scope.new
- @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
- @scope.parent = @topscope
- @compiler = @scope.compiler
- end
-
- describe 'when calling validate_string from puppet' do
-
- %w{ foo bar baz }.each do |the_string|
-
- it "should compile when #{the_string} is a string" do
- Puppet[:code] = "validate_string('#{the_string}')"
- get_scope
- @scope.compiler.compile
- end
-
- it "should compile when #{the_string} is a bare word" do
- Puppet[:code] = "validate_string(#{the_string})"
- get_scope
- @scope.compiler.compile
- end
-
- end
-
- %w{ true false }.each do |the_string|
- it "should compile when #{the_string} is a string" do
- Puppet[:code] = "validate_string('#{the_string}')"
- get_scope
- @scope.compiler.compile
- end
-
- it "should not compile when #{the_string} is a bare word" do
- Puppet[:code] = "validate_string(#{the_string})"
- get_scope
- expect { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /is not a string/)
- end
- end
-
- it "should compile when multiple string arguments are passed" do
- Puppet[:code] = <<-'ENDofPUPPETcode'
- $foo = ''
- $bar = 'two'
- validate_string($foo, $bar)
- ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
- end
-
- it "should compile when an explicitly undef variable is passed (NOTE THIS MAY NOT BE DESIRABLE)" do
- Puppet[:code] = <<-'ENDofPUPPETcode'
- $foo = undef
- validate_string($foo)
- ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
- end
-
- it "should compile when an undefined variable is passed (NOTE THIS MAY NOT BE DESIRABLE)" do
- Puppet[:code] = <<-'ENDofPUPPETcode'
- validate_string($foobarbazishouldnotexist)
- ENDofPUPPETcode
- get_scope
- @scope.compiler.compile
- end
- end
-end
-
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the values_at function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("values_at").should == "function_values_at"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_values_at([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should raise a ParseError if you try to use a range where stop is greater then start" do
- lambda { @scope.function_values_at([['a','b'],["3-1"]]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return a value at from an array" do
- result = @scope.function_values_at([['a','b','c'],"1"])
- result.should(eq(['b']))
- end
-
- it "should return a value at from an array when passed a range" do
- result = @scope.function_values_at([['a','b','c'],"0-1"])
- result.should(eq(['a','b']))
- end
-
- it "should return chosen values from an array when passed number of indexes" do
- result = @scope.function_values_at([['a','b','c'],["0","2"]])
- result.should(eq(['a','c']))
- end
-
- it "should return chosen values from an array when passed ranges and multiple indexes" do
- result = @scope.function_values_at([['a','b','c','d','e','f','g'],["0","2","4-5"]])
- result.should(eq(['a','c','e','f']))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the values function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("values").should == "function_values"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_values([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should return values from a hash" do
- result = @scope.function_values([{'a'=>'1','b'=>'2','c'=>'3'}])
- result.should(eq(['1','2','3']))
- end
-
- it "should return values from a hash" do
- lambda { @scope.function_values([['a','b','c']]) }.should( raise_error(Puppet::ParseError))
- end
-
-end
+++ /dev/null
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe "the zip function" do
- before :all do
- Puppet::Parser::Functions.autoloader.loadall
- end
-
- before :each do
- @scope = Puppet::Parser::Scope.new
- end
-
- it "should exist" do
- Puppet::Parser::Functions.function("zip").should == "function_zip"
- end
-
- it "should raise a ParseError if there is less than 1 arguments" do
- lambda { @scope.function_zip([]) }.should( raise_error(Puppet::ParseError))
- end
-
- it "should be able to zip an array" do
- result = @scope.function_zip([['1','2','3'],['4','5','6']])
- result.should(eq([["1", "4"], ["2", "5"], ["3", "6"]]))
- end
-
-end
+++ /dev/null
-require 'puppet'
-require 'tempfile'
-provider_class = Puppet::Type.type(:file_line).provider(:ruby)
-describe provider_class do
- before :each do
- tmp = Tempfile.new('tmp')
- @tmpfile = tmp.path
- tmp.close!
- @resource = Puppet::Type::File_line.new(
- {:name => 'foo', :path => @tmpfile, :line => 'foo'}
- )
- @provider = provider_class.new(@resource)
- end
- it 'should detect if the line exists in the file' do
- File.open(@tmpfile, 'w') do |fh|
- fh.write('foo')
- end
- @provider.exists?.should be_true
- end
- it 'should detect if the line does not exist in the file' do
- File.open(@tmpfile, 'w') do |fh|
- fh.write('foo1')
- end
- @provider.exists?.should be_nil
- end
- it 'should append to an existing file when creating' do
- @provider.create
- File.read(@tmpfile).chomp.should == 'foo'
- end
-end
+++ /dev/null
-#!/usr/bin/env ruby
-
-require 'puppet'
-
-anchor = Puppet::Type.type(:anchor).new(:name => "ntp::begin")
-
-describe anchor do
- it "should stringify normally" do
- anchor.to_s.should == "Anchor[ntp::begin]"
- end
-end
+++ /dev/null
-require 'puppet'
-require 'tempfile'
-describe Puppet::Type.type(:file_line) do
- before :each do
- @file_line = Puppet::Type.type(:file_line).new(:name => 'foo', :line => 'line', :path => '/tmp/path')
- end
- it 'should accept a line and path' do
- @file_line[:line] = 'my_line'
- @file_line[:line].should == 'my_line'
- end
- it 'should accept posix filenames' do
- @file_line[:path] = '/tmp/path'
- @file_line[:path].should == '/tmp/path'
- end
- it 'should not accept unqualified path' do
- expect { @file_line[:path] = 'file' }.should raise_error(Puppet::Error, /File paths must be fully qualified/)
- end
- it 'should require that a line is specified' do
- expect { Puppet::Type.type(:file_line).new(:name => 'foo', :path => '/tmp/file') }.should raise_error(Puppet::Error, /Both line and path are required attributes/)
- end
- it 'should require that a file is specified' do
- expect { Puppet::Type.type(:file_line).new(:name => 'foo', :line => 'path') }.should raise_error(Puppet::Error, /Both line and path are required attributes/)
- end
-end
+++ /dev/null
-ENV['FOG_MOCK'] ||= 'true'
-ENV['AUTOTEST'] = 'true'
-ENV['WATCHR'] = '1'
-
-system 'clear'
-
-def growl(message)
- growlnotify = `which growlnotify`.chomp
- title = "Watchr Test Results"
- image = case message
- when /(\d+)\s+?(failure|error)/i
- ($1.to_i == 0) ? "~/.watchr_images/passed.png" : "~/.watchr_images/failed.png"
- else
- '~/.watchr_images/unknown.png'
- end
- options = "-w -n Watchr --image '#{File.expand_path(image)}' -m '#{message}' '#{title}'"
- system %(#{growlnotify} #{options} &)
-end
-
-def run(cmd)
- puts(cmd)
- `#{cmd}`
-end
-
-def run_spec_test(file)
- if File.exist? file
- result = run "rspec --format p --color #{file}"
- growl result.split("\n").last
- puts result
- else
- puts "FIXME: No test #{file} [#{Time.now}]"
- end
-end
-
-def filter_rspec(data)
- data.split("\n").find_all do |l|
- l =~ /^(\d+)\s+exampl\w+.*?(\d+).*?failur\w+.*?(\d+).*?pending/
- end.join("\n")
-end
-
-def run_all_tests
- system('clear')
- files = Dir.glob("spec/**/*_spec.rb").join(" ")
- result = run "rspec #{files}"
- growl_results = filter_rspec result
- growl growl_results
- puts result
- puts "GROWL: #{growl_results}"
-end
-
-# Ctrl-\
-Signal.trap 'QUIT' do
- puts " --- Running all tests ---\n\n"
- run_all_tests
-end
-
-@interrupted = false
-
-# Ctrl-C
-Signal.trap 'INT' do
- if @interrupted then
- @wants_to_quit = true
- abort("\n")
- else
- puts "Interrupt a second time to quit"
- @interrupted = true
- Kernel.sleep 1.5
- # raise Interrupt, nil # let the run loop catch it
- run_suite
- end
-end
-
-def file2spec(file)
- result = file.sub('lib/puppet/', 'spec/unit/puppet/').gsub(/\.rb$/, '_spec.rb')
- result = file.sub('lib/facter/', 'spec/unit/facter/').gsub(/\.rb$/, '_spec.rb')
-end
-
-
-watch( 'spec/.*_spec\.rb' ) do |md|
- #run_spec_test(md[0])
- run_all_tests
-end
-watch( 'lib/.*\.rb' ) do |md|
- # run_spec_test(file2spec(md[0]))
- run_all_tests
-end
+++ /dev/null
-# This is a simple smoke test
-# of the file_line resource type.
-file { '/tmp/dansfile':
- ensure => present
-}->
-file_line { 'dans_line':
- line => 'dan is awesome',
- path => '/tmp/dansfile',
-}
+++ /dev/null
-include stdlib
projects / dsa-puppet.git / commitdiff