diff --git a/Puppetfile b/Puppetfile index 3b38aab27..63ee57554 100644 --- a/Puppetfile +++ b/Puppetfile @@ -171,7 +171,7 @@ mod 'staging', :git => 'https://github.com/nanliu/puppet-staging.git' mod 'stdlib', - :commit => '62e8c1d76902e6f22cb9f7b3abd43e757b4130a3', + :commit => 'ad5727266a5c243cebf8007b9b00ffc80674b4fc', :git => 'https://github.com/puppetlabs/puppetlabs-stdlib.git' mod 'swift', diff --git a/stdlib/.fixtures.yml b/stdlib/.fixtures.yml new file mode 100644 index 000000000..37b737752 --- /dev/null +++ b/stdlib/.fixtures.yml @@ -0,0 +1,3 @@ +fixtures: + symlinks: + stdlib: "#{source_dir}" diff --git a/stdlib/.gitignore b/stdlib/.gitignore index 7d0fd8d0a..b5db85e05 100644 --- a/stdlib/.gitignore +++ b/stdlib/.gitignore @@ -1,7 +1,9 @@ pkg/ -.DS_Store -coverage/ -spec/fixtures/ Gemfile.lock +vendor/ +spec/fixtures/ +.vagrant/ .bundle/ -vendor/bundle/ +coverage/ +.idea/ +*.iml diff --git a/stdlib/.sync.yml b/stdlib/.sync.yml new file mode 100644 index 000000000..21e872e0c --- /dev/null +++ b/stdlib/.sync.yml @@ -0,0 +1,9 @@ +--- +.travis.yml: + script: "\"bundle exec rake validate && bundle exec rake lint && bundle exec rake spec SPEC_OPTS='--color --format documentation'\"" +Rakefile: + unmanaged: true +Gemfile: + unmanaged: true +spec/spec_helper.rb: + unmanaged: true diff --git a/stdlib/.travis.yml b/stdlib/.travis.yml index 34d8cc949..503e1844d 100644 --- a/stdlib/.travis.yml +++ b/stdlib/.travis.yml @@ -1,27 +1,18 @@ --- +sudo: false language: ruby -bundler_args: --without development +bundler_args: --without system_tests script: "bundle exec rake validate && bundle exec rake lint && bundle exec rake spec SPEC_OPTS='--color --format documentation'" -rvm: - - 1.8.7 - - 1.9.3 - - 2.0.0 - - ruby-head -env: - - PUPPET_GEM_VERSION=">= 3.0.0" matrix: fast_finish: true - allow_failures: - - rvm: 2.0.0 - - rvm: ruby-head include: - - rvm: 1.8.7 - env: PUPPET_GEM_VERSION="~> 2.7" + - rvm: 1.8.7 + env: PUPPET_GEM_VERSION="~> 2.7.0" FACTER_GEM_VERSION="~> 1.6.0" + - rvm: 1.8.7 + env: PUPPET_GEM_VERSION="~> 2.7.0" FACTER_GEM_VERSION="~> 1.7.0" + - rvm: 1.9.3 + env: PUPPET_GEM_VERSION="~> 3.0" + - rvm: 2.0.0 + env: PUPPET_GEM_VERSION="~> 3.0" notifications: email: false - webhooks: - urls: - - https://puppet-dev-community.herokuapp.com/event/travis-ci/ - on_success: always - on_failure: always - on_start: yes diff --git a/stdlib/CHANGELOG.md b/stdlib/CHANGELOG.md index f1326497b..138569507 100644 --- a/stdlib/CHANGELOG.md +++ b/stdlib/CHANGELOG.md @@ -1,3 +1,129 @@ +##2015-01-14 - Supported Release 4.6.0 +###Summary + +Improved functionality and preparing for Puppet Next with new parser + +####Features +- MODULES-444: concat can now take more than two arrays +- basename function added to have Ruby File.basename functionality +- delete function can now take an array of items to remove +- MODULES-1473: deprecate type function in favor of type_of + +####Bugfixes +- Several test case fixes +- Ensure_resource is more verbose on debug mode + +##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 diff --git a/stdlib/CONTRIBUTING.md b/stdlib/CONTRIBUTING.md index 5280da15e..f1cbde4bb 100644 --- a/stdlib/CONTRIBUTING.md +++ b/stdlib/CONTRIBUTING.md @@ -1,65 +1,220 @@ -# How to contribute - -Third-party patches are essential for keeping stdlib great. We simply can't -access the huge number of platforms and myriad configurations for running -stdlib. We want to keep it as easy as possible to contribute changes that -get things working 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. - -## Getting Started - -* Make sure you have a [Jira account](http://tickets.puppetlabs.com) -* Make sure you have a [GitHub account](https://github.com/signup/free) -* Submit a ticket for your issue, assuming one does not already exist. - * Clearly describe the issue including steps to reproduce when it is a bug. - * Make sure you fill in the earliest version that you know has the issue. -* Fork the repository on GitHub - -## Making Changes - -* Create a topic branch from where you want to base your work. - * This is usually the master branch. - * Only target release branches if you are certain your fix must be on that - branch. - * To quickly create a topic branch based on master; `git branch - fix/master/my_contribution master` then checkout the new branch with `git - checkout fix/master/my_contribution`. Please avoid working directly on the - `master` branch. -* Make commits of logical units. -* Check for unnecessary whitespace with `git diff --check` before committing. -* Make sure your commit messages are in the proper format. - -```` - (#99999) Make the example in CONTRIBUTING imperative and concrete - - Without this patch applied the example commit message in the CONTRIBUTING - document is not a concrete example. This is a problem because the - contributor is left to imagine what the commit message should look like - based on a description rather than an example. This patch fixes the - problem by making the example concrete and imperative. - - The first line is a real life imperative statement with a ticket number - from our issue tracker. The body describes the behavior without the patch, - why this is a problem, and how the patch fixes the problem when applied. -```` - -* Make sure you have added the necessary tests for your changes. -* Run _all_ the tests to assure nothing else was accidentally broken. - -## Submitting Changes - -* Sign the [Contributor License Agreement](http://links.puppetlabs.com/cla). -* Push your changes to a topic branch in your fork of the repository. -* Submit a pull request to the repository in the puppetlabs organization. -* Update your ticket to mark that you have submitted code and are ready for it to be reviewed. - * Include a link to the pull request in the ticket - -# Additional Resources - -* [More information on contributing](http://links.puppetlabs.com/contribute-to-puppet) -* [Bug tracker (Jira)](http://tickets.puppetlabs.com) -* [Contributor License Agreement](http://links.puppetlabs.com/cla) +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/) -* #puppet-dev IRC channel on freenode.org + diff --git a/stdlib/Gemfile b/stdlib/Gemfile index eb5a31c76..fa2a31cbc 100644 --- a/stdlib/Gemfile +++ b/stdlib/Gemfile @@ -10,23 +10,29 @@ def location_for(place, fake_version = nil) end end -group :development, :test do +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 'rspec-system', :require => false - gem 'rspec-system-puppet', :require => false - gem 'rspec-system-serverspec', :require => false - gem 'serverspec', :require => false gem 'puppet-lint', :require => false gem 'pry', :require => false gem 'simplecov', :require => false - gem 'beaker', :require => false +end + +group :system_tests do gem 'beaker-rspec', :require => false + 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 -ENV['GEM_PUPPET_VERSION'] ||= ENV['PUPPET_GEM_VERSION'] -puppetversion = ENV['GEM_PUPPET_VERSION'] +puppetversion = ENV['GEM_PUPPET_VERSION'] || ENV['PUPPET_GEM_VERSION'] if puppetversion gem 'puppet', *location_for(puppetversion) else diff --git a/stdlib/Modulefile b/stdlib/Modulefile deleted file mode 100644 index 9d2e8c220..000000000 --- a/stdlib/Modulefile +++ /dev/null @@ -1,11 +0,0 @@ -name 'puppetlabs-stdlib' -version '4.1.0' -source 'git://github.com/puppetlabs/puppetlabs-stdlib.git' -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' diff --git a/stdlib/README.markdown b/stdlib/README.markdown index 76c546f14..e9a1f4e4f 100644 --- a/stdlib/README.markdown +++ b/stdlib/README.markdown @@ -1,9 +1,25 @@ -# Puppet Labs Standard Library # +#stdlib [![Build Status](https://travis-ci.org/puppetlabs/puppetlabs-stdlib.png?branch=master)](https://travis-ci.org/puppetlabs/puppetlabs-stdlib) -This module provides a "standard library" of resources for developing Puppet -Modules. This modules will include the following additions to Puppet +####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 @@ -12,1286 +28,714 @@ Modules. This modules will include the following additions to Puppet * 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. - -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) - -# 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) - * v2.2.x (Never released as part of PE, only to the Forge) - * v2.3.x (Released in PE 2) - * v3.0.x (Released in PE 3) - * v4.0.x (Maintains compatibility with v3.x despite the major semantic version bump. Compatible with Puppet 2.7.x) - * v5.x (To be released when stdlib can drop support for Puppet 2.7.x. Please see [this discussion](https://github.com/puppetlabs/puppetlabs-stdlib/pull/176#issuecomment-30251414)) - * master (mainline development branch) - -The first Puppet Enterprise version including the stdlib module is Puppet -Enterprise 1.2. - -# Compatibility # - -Puppet Versions | < 2.6 | 2.6 | 2.7 | 3.x | -:---------------|:-----:|:---:|:---:|:----: -**stdlib 2.x** | no | **yes** | **yes** | no -**stdlib 3.x** | no | no | **yes** | **yes** -**stdlib 4.x** | no | no | **yes** | **yes** - -The stdlib module does not work with Puppet versions released prior to Puppet -2.6.0. - -## stdlib 2.x ## - -All stdlib releases in the 2.0 major version support Puppet 2.6 and Puppet 2.7. - -## stdlib 3.x ## - -The 3.0 major release of stdlib drops support for Puppet 2.6. Stdlib 3.x -supports Puppet 2 and Puppet 3. - -## stdlib 4.x ## - -The 4.0 major release of stdlib was intended to drop support for Puppet 2.7, -but the impact on end users was too high. The decision was made to treat -stdlib 4.x as a continuation of stdlib 3.x support. Stdlib 4.x supports Puppet -2.7 and 3. Notably, ruby 1.8.5 is no longer supported though ruby -1.8.7, 1.9.3, and 2.0.0 are fully supported. - -# 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 - +> *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. -- *Type*: rvalue +##Setup -bool2num --------- -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. +Installing the stdlib module adds the functions, facts, and resources of this standard library to Puppet. +##Usage -- *Type*: rvalue +After you've installed stdlib, all of its functions, facts, and resources are available for module use or development. -capitalize ----------- -Capitalizes the first letter of a string or array of strings. -Requires either a single string or an array as an input. +If you want to use a standardized set of run stages for Puppet, `include stdlib` in your manifest. +## Reference -- *Type*: rvalue +### Classes -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. +#### 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`. -- *Type*: rvalue + When declared, stdlib declares all other classes in the module. The only other class currently included in the module is `stdlib::stages`. -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 wish to merely remove record -separators then you should use the `chomp` function. -Requires a string or array of strings as input. + The stdlib class has no parameters. +#### Private Classes -- *Type*: rvalue +* `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. -concat ------- -Appends the contents of array 2 onto array 1. + The `stdlib::stages` class declares various run stages for deploying infrastructure, language runtimes, and application layers. The high level stages are (in order): -*Example:* + * setup + * main + * runtime + * setup_infra + * deploy_infra + * setup_app + * deploy_app + * deploy - concat(['1','2','3'],['4','5','6']) + Sample usage: -Would result in: + ``` + node default { + include stdlib + class { java: stage => 'runtime' } + } + ``` - ['1','2','3','4','5','6'] +### 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. -- *Type*: rvalue + ``` + 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', + } + ``` -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. + * `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 -- *Type*: rvalue +* `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 -defined_with_params -------------------- -Takes a resource reference and an optional hash of attributes. +* `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 -Returns true if a resource with the specified attributes has already been added -to the catalog, and false otherwise. +* `base64`: Converts a string to and from base64 encoding. +Requires an action ('encode', 'decode') and either a plain or base64-encoded +string. *Type*: rvalue - user { 'dan': - ensure => present, - } +* `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' - if ! defined_with_params(User[dan], {'ensure' => 'present' }) { - user { 'dan': ensure => present, } - } + *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 -- *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 -delete ------- -Deletes all instances of a given element from an array, substring from a -string, or key from a hash. +* `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 -*Examples:* +* `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 - delete(['a','b','c','b'], 'b') - Would return: ['a','c'] +* `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']. - delete({'a'=>1,'b'=>2,'c'=>3}, 'b') - Would return: {'a'=>1,'c'=>3} +* `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 - delete('abracadabra', 'bra') - Would return: 'acada' +* `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, + } -- *Type*: rvalue + if ! defined_with_params(User[dan], {'ensure' => 'present' }) { + user { 'dan': ensure => present, } + } + ``` -delete_at ---------- -Deletes a determined indexed value from an array. + *Type*: rvalue -*Examples:* +* `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(['a','b','c'], 1) +* `delete_at`: Deletes a determined indexed value from an array. For example, `delete_at(['a','b','c'], 1)` returns ['a','c']. *Type*: rvalue -Would return: ['a','c'] +* `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 -- *Type*: rvalue - -delete_values -------------- -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'} - - -- *Type*: rvalue - -delete_undef_values -------------------- -Deletes all instances of the undef value from an array or hash. - -*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] - -- *Type*: rvalue - -difference ----------- -This function returns the difference between two arrays. +* `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. - -*Examples:* - - difference(["a","b","c"],["b","c","d"]) - -Would return: ["a"] - -dirname -------- -Returns the `dirname` of a path. - -*Examples:* - - dirname('/path/to/a/file.ext') - -Would return: '/path/to/a' - -downcase --------- -Converts the case of a string or all strings in an array to lower case. - - -- *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. - - -- *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 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'}) - - - -- *Type*: statement - -file_line ---------- -This resource ensures that a given line is contained within a file. You can also use -"match" to replace existing lines. - -*Examples:* - - file_line { 'sudo_rule': - path => '/etc/sudoers', - line => '%sudo ALL=(ALL) ALL', - } - - file_line { 'change_mount': - path => '/etc/fstab', - line => '10.0.0.1:/vol/data /opt/data nfs defaults 0 0', - match => '^172.16.17.2:/vol/old', - } - -- *Type*: resource - -flatten -------- -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'] - - -- *Type*: rvalue - -floor ------ -Returns the largest integer less or equal to the argument. -Takes a single numeric value as an argument. - - -- *Type*: rvalue - -fqdn_rotate ------------ -Rotates an array a random number of times based on a nodes fqdn. - - -- *Type*: rvalue - -get_module_path ---------------- -Returns the absolute path of the specified module for the current -environment. - -Example: - $module_path = get_module_path('stdlib') - - -- *Type*: rvalue - -getparam --------- -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 - - -- *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. - -*Examples:* - - grep(['aaa','bbb','ccc','aaaddd'], 'aaa') - -Would return: - - ['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 - -etc. - -If no "kind" is given, then the presence of the interface is checked: +also appear in the second array. For example, `difference(["a","b","c"],["b","c","d"])` returns ["a"]. - has_interface_with("lo") => true +* `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 -- *Type*: rvalue +* `empty`: Returns 'true' if the variable is empty. *Type*: rvalue -has_ip_address --------------- -Returns true if the client has the requested IP address on some interface. +* `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 -This function iterates through the 'interfaces' fact and checks the -'ipaddress_IFACE' facts, performing a simple string comparison. +* `ensure_resource`: Takes a resource type, title, and a list of attributes that describe a resource. + ``` + user { 'dan': + ensure => present, + } + ``` -- *Type*: rvalue + This example only creates the resource if it does not already exist: -has_ip_network --------------- -Returns true if the client has an IP address within the requested network. + `ensure_resource('user', 'dan', {'ensure' => 'present' })` -This function iterates through the 'interfaces' fact and checks the -'network_IFACE' facts, performing a simple string comparision. + 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. -- *Type*: rvalue + `ensure_resource('user', ['dan','alex'], {'ensure' => 'present'})` -has_key -------- -Determine if a hash has a certain key value. + *Type*: statement -Example: +* `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 - $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') - } +* `floor`: Returns the largest integer less than or equal to the argument. +Takes a single numeric value as an argument. *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. -- *Type*: rvalue + `$module_path = get_module_path('stdlib')` -hash ----- -This function converts an array into a hash. + *Type*: rvalue -*Examples:* +* `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'. - hash(['a',1,'b',2,'c',3]) + *Example:* -Would return: {'a'=>1,'b'=>2,'c'=>3} + ``` + define example_resource($param) { + } + example_resource { "example_resource_instance": + param => "param_value" + } -- *Type*: rvalue + getparam(Example_resource["example_resource_instance"], "param") + ``` -intersection ------------ -This function returns an array an intersection of two. + *Type*: rvalue -*Examples:* +* `getvar`: Lookup a variable in a remote namespace. - intersection(["a","b","c"],["b","c","d"]) + For example: -Would return: ["b","c"] + ``` + $foo = getvar('site::data::foo') + # Equivalent to $foo = $site::data::foo + ``` -is_array --------- -Returns true if the variable passed to this function is an array. + This is useful if the namespace itself is stored in a string: -- *Type*: rvalue + ``` + $datalocation = 'site::data' + $bar = getvar("${datalocation}::bar") + # Equivalent to $bar = $site::data::bar + ``` -is_bool --------- -Returns true if the variable passed to this function is a boolean. + *Type*: rvalue -- *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 -is_domain_name --------------- -Returns true if the string passed to this function is a syntactically correct domain name. +* `has_interface_with`: Returns boolean based on kind and value: + * macaddress + * netmask + * ipaddress + * network -- *Type*: rvalue + *Examples:* -is_float --------- -Returns true if the variable passed to this function is a float. + ``` + has_interface_with("macaddress", "x:x:x:x:x:x") + has_interface_with("ipaddress", "127.0.0.1") => true + ``` -- *Type*: rvalue + If no kind is given, then the presence of the interface is checked: -is_function_available ---------------------- -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. + ``` + has_interface_with("lo") => true + ``` -- *Type*: rvalue + *Type*: rvalue -is_hash -------- -Returns true if the variable passed to this function is a hash. +* `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 -- *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 -is_integer ----------- -Returns true if the variable returned to this string is an integer. +* `has_key`: Determine if a hash has a certain key value. -- *Type*: rvalue + *Example*: -is_ip_address -------------- -Returns true if the string passed to this function is a valid IP address. + ``` + $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 + *Type*: rvalue -is_mac_address --------------- -Returns true if the string passed to this function is a valid mac address. +* `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 -- *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_numeric ----------- -Returns true if the variable passed to this function is a number. +* `is_array`: Returns 'true' if the variable passed to this function is an array. *Type*: rvalue -- *Type*: rvalue +* `is_bool`: Returns 'true' if the variable passed to this function is a boolean. *Type*: rvalue -is_string ---------- -Returns true if the variable passed to this function is a string. +* `is_domain_name`: Returns 'true' if the string passed to this function is a syntactically correct domain name. *Type*: rvalue -- *Type*: rvalue +* `is_float`: Returns 'true' if the variable passed to this function is a float. *Type*: rvalue -join ----- -This function joins an array into a string using a separator. +* `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 -*Examples:* +* `is_hash`: Returns 'true' if the variable passed to this function is a hash. *Type*: rvalue - join(['a','b','c'], ",") +* `is_integer`: Returns 'true' if the variable returned to this string is an integer. *Type*: rvalue -Would result in: "a,b,c" +* `is_ip_address`: Returns 'true' if the string passed to this function is a valid IP address. *Type*: rvalue -- *Type*: rvalue +* `is_mac_address`: Returns 'true' if the string passed to this function is a valid MAC address. *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. +* `is_numeric`: Returns 'true' if the variable passed to this function is a number. *Type*: rvalue -*Examples:* +* `is_string`: Returns 'true' if the variable passed to this function is a string. *Type*: rvalue - join_keys_to_values({'a'=>1,'b'=>2}, " is ") +* `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 -Would result in: ["a is 1","b is 2"] +* `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 -- *Type*: rvalue +* `keys`: Returns the keys of a hash as an array. *Type*: rvalue -keys ----- -Returns the keys of a hash as an array. +* `loadyaml`: Load a YAML file containing an array, string, or hash, and return the data in the corresponding native data type. For example: -- *Type*: rvalue + ``` + $myhash = loadyaml('/etc/puppet/data/myhash.yaml') + ``` -loadyaml --------- -Load a YAML file containing an array, string, or hash, and return the data -in the corresponding native data type. + *Type*: rvalue -For example: +* `lstrip`: Strips leading spaces to the left of a string. *Type*: rvalue - $myhash = loadyaml('/etc/puppet/data/myhash.yaml') +* `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 -- *Type*: rvalue +* `merge`: Merges two or more hashes together and returns the resulting hash. -lstrip ------- -Strips leading spaces to the left of a string. + *Example*: -- *Type*: rvalue + ``` + $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'} + ``` -max ---- -Returns the highest value of all arguments. -Requires at least one argument. + When there is a duplicate key, the key in the rightmost hash "wins." *Type*: rvalue -- *Type*: rvalue +* `min`: Returns the lowest value of all arguments. Requires at least one argument. *Type*: rvalue -member ------- -This function determines if a variable is a member of an array. +* `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 -*Examples:* +* `parsejson`: This function accepts JSON as a string and converts into the correct Puppet structure. *Type*: rvalue - member(['a','b'], 'b') +* `parseyaml`: This function accepts YAML as a string and converts it into the correct Puppet structure. *Type*: rvalue -Would return: true +* `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. - member(['a','b'], 'c') + ``` + $real_jenkins_version = pick($::jenkins_version, '1.449') + ``` -Would return: false + *Type*: rvalue -- *Type*: rvalue +* `prefix`: This function applies a prefix to all elements in an array. For example, `prefix(['a','b','c'], 'p')` returns ['pa','pb','pc']. *Type*: rvalue -merge ------ -Merges two or more hashes together and returns the resulting hash. -For example: +* `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, `private()` called in class `foo::bar` outputs the following message if class is called from outside module `foo`: - $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'} + ``` + Class foo::bar is private + ``` -When there is a duplicate key, the key in the rightmost hash will "win." + You can specify the error message you want to use: -- *Type*: rvalue + ``` + private("You're not supposed to do that!") + ``` -min ---- -Returns the lowest value of all arguments. -Requires at least one argument. + *Type*: statement -- *Type*: rvalue +* `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]. -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 higher then 0 -become true. + Non-integer strings are accepted; `range("a", "c")` returns ["a","b","c"], and `range("host01", "host10")` returns ["host01", "host02", ..., "host09", "host10"]. -- *Type*: rvalue + *Type*: rvalue -parsejson ---------- -This function accepts JSON as a string and converts into the correct Puppet -structure. +* `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 -- *Type*: rvalue +* `reverse`: Reverses the order of a string or array. *Type*: rvalue -parseyaml ---------- -This function accepts YAML as a string and converts it into the correct -Puppet structure. +* `rstrip`: Strips leading spaces to the right of the string.*Type*: rvalue -- *Type*: rvalue +* `shuffle`: Randomizes the order of a string or array elements. *Type*: rvalue -pick ----- -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: +* `size`: Returns the number of elements in a string or array. *Type*: rvalue - $real_jenkins_version = pick($::jenkins_version, '1.449') +* `sort`: Sorts strings and arrays lexically. *Type*: rvalue -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. +* `squeeze`: Returns a new string where runs of the same character that occur in this set are replaced by a single character. *Type*: rvalue -- *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 -prefix ------- -This function applies a prefix to all elements in an array. +* `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 -*Examples:* +* `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 - prefix(['a','b','c'], 'p') + *Format:* -Will return: ['pa','pb','pc'] + * `%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 -- *Type*: rvalue -range ------ -When given range in the form of (start, stop) it will extrapolate a range as -an array. +* `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 -*Examples:* +* `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 - range("0", "9") +* `swapcase`: This function swaps the existing case of a string. For example, `swapcase("aBcD")` results in "AbCd". *Type*: rvalue -Will return: [0,1,2,3,4,5,6,7,8,9] +* `time`: This function returns the current time since epoch as an integer. For example, `time()` returns something like '1311972653'. *Type*: rvalue - range("00", "09") +* `to_bytes`: Converts the argument into bytes, for example 4 kB becomes 4096. +Takes a single string value as an argument. *Type*: rvalue -Will return: [0,1,2,3,4,5,6,7,8,9] - Zero padded strings are converted to -integers automatically +* `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 - range("a", "c") +* `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 -Will return: ["a","b","c"] +* `union`: This function returns a union of two arrays. For example, `union(["a","b","c"],["b","c","d"])` returns ["a","b","c","d"]. - range("host01", "host10") +* `unique`: This function removes duplicates from strings and arrays. For example, `unique("aabbcc")` returns 'abc'. -Will return: ["host01", "host02", ..., "host09", "host10"] +You can also use this with arrays. For example, `unique(["a","a","b","b","c","c"])` returns ["a","b","c"]. *Type*: rvalue -- *Type*: rvalue +* `upcase`: Converts a string or an array of strings to uppercase. For example, `upcase("abcd")` returns 'ABCD'. *Type*: rvalue -reject ------- -This function searches through an array and rejects all elements that match -the provided regular expression. +* `uriescape`: Urlencodes a string or array of strings. Requires either a single string or an array as an input. *Type*: rvalue -*Examples:* +* `validate_absolute_path`: Validate the string represents an absolute path in the filesystem. This function works for Windows and Unix style paths. - reject(['aaa','bbb','ccc','aaaddd'], 'aaa') + The following values will pass: -Would return: - - ['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 things like: y, 1, t, true to 'true' and strings that contain things -like: 0, f, n, false, no to 'false'. - - -- *Type*: rvalue - -str2saltedsha512 ----------------- -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. - - -- *Type*: rvalue - -strftime --------- -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 - 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 - - -- *Type*: rvalue - -strip ------ -This function removes leading and trailing whitespace from a string or from -every string inside an array. - -*Examples:* - - strip(" aaa ") - -Would result in: "aaa" - - -- *Type*: rvalue - -suffix ------- -This function applies a suffix to all elements in an array. - -*Examples:* - - suffix(['a','b','c'], 'p') - -Will return: ['ap','bp','cp'] - - -- *Type*: rvalue - -swapcase --------- -This function will swap the existing case of a string. - -*Examples:* - - swapcase("aBcD") - -Would result in: "AbCd" - - -- *Type*: rvalue - -time ----- -This function will return the current time since epoch as an integer. - -*Examples:* - - time() - -Will return 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 - -type ----- -Returns the type when passed a variable. Type can be one of: - -* string -* array -* hash -* float -* integer -* boolean - - -- *Type*: rvalue - -union ------ -This function returns a union of two arrays. - -*Examples:* - - union(["a","b","c"],["b","c","d"]) - -Would return: ["a","b","c","d"] - - -unique ------- -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"] - - -- *Type*: rvalue - -upcase ------- -Converts a string or an array of strings to uppercase. - -*Examples:* - - upcase("abcd") - -Will return: - - 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" + ``` + $my_path = 'C:/Program Files (x86)/Puppet Labs/Puppet' validate_absolute_path($my_path) - $my_path2 = "/var/lib/puppet" + $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: -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. -- *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 ---------------- -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: + The following values will pass: - validate_augeas($passwdcontent, 'Passwd.lns', ['$file/foo']) + ``` + $my_array = [ 'one', 'two' ] + validate_array($my_array) + ``` -Or if you wanted to ensure that no users used the '/bin/barsh' shell, -you could use: + The following values will fail, causing compilation to abort: - validate_augeas($passwdcontent, 'Passwd.lns', ['$file/*[shell="/bin/barsh"]'] + ``` + validate_array(true) + validate_array('some_string') + $undefined = undef + validate_array($undefined) + ``` -If a fourth argument is specified, this will be the error message raised and -seen by the user. + *Type*: statement -A helpful error message can be returned like this: +* `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. - validate_augeas($sudoerscontent, 'Sudoers.lns', [], 'Failed to validate sudoers content with Augeas') + 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']) + ``` -- *Type*: statement + To ensure that no users use the '/bin/barsh' shell: -validate_bool -------------- -Validate that all passed values are either true or false. Abort catalog -compilation if any value fails this check. + ``` + validate_augeas($passwdcontent, 'Passwd.lns', ['$file/*[shell="/bin/barsh"]'] + ``` -The following values will pass: + You can pass a fourth argument as the error message raised and shown to the user: - $iamtrue = true - validate_bool(true) - validate_bool(true, true, false, $iamtrue) + ``` + validate_augeas($sudoerscontent, 'Sudoers.lns', [], 'Failed to validate sudoers content with Augeas') + ``` -The following values will fail, causing compilation to abort: + *Type*: statement - $some_array = [ true ] - validate_bool("false") - validate_bool("true") - validate_bool($some_array) +* `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) + ``` -- *Type*: statement + The following values will fail, causing compilation to abort: -validate_cmd ------------- -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 file as last argument. If the command, launched against -a tempfile containing the passed string, returns a non-null value, -compilation will abort with a parse error. + ``` + $some_array = [ true ] + validate_bool("false") + validate_bool("true") + validate_bool($some_array) + ``` -If a third argument is specified, this will be the error message raised and -seen by the user. + *Type*: statement -A helpful error message can be returned like this: +* `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. -Example: +If a third argument is specified, this will be the error message raised and seen by the user. - validate_cmd($sudoerscontent, '/usr/sbin/visudo -c -f', 'Visudo failed to validate sudoers content') + ``` + # 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. -- *Type*: statement + The following values will pass: -validate_hash -------------- -Validate that all passed values are hash data structures. Abort catalog -compilation if any value fails this check. + ``` + $my_hash = { 'one' => 'two' } + validate_hash($my_hash) + ``` -The following values will pass: + The following values will fail, causing compilation to abort: - $my_hash = { 'one' => 'two' } - validate_hash($my_hash) + ``` + validate_hash(true) + validate_hash('some_string') + $undefined = undef + validate_hash($undefined) + ``` -The following values will fail, causing compilation to abort: + *Type*: statement - validate_hash(true) - validate_hash('some_string') - $undefined = undef - validate_hash($undefined) - - - -- *Type*: statement - -validate_re ------------ -Perform simple validation of a string against one or more regular -expressions. The first argument of this function should be a string to +* `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 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: +(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. - validate_re('one', '^one$') - validate_re('one', [ '^one', '^two' ]) + You can pass a third argument as the error message raised and shown to the user. -The following strings will fail to validate, causing compilation to abort: + The following strings validate against the regular expressions: - validate_re('one', [ '^two', '^three' ]) + ``` + validate_re('one', '^one$') + validate_re('one', [ '^one', '^two' ]) + ``` -A helpful error message can be returned like this: + The following string fails to validate, causing compilation to abort: - validate_re($::puppetversion, '^2.7', 'The $puppetversion fact value does not match 2.7') + ``` + 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 + *Type*: statement -validate_slength ----------------- -Validate that the first argument is a string (or an array of strings), and -less/equal to than the length of the second argument. It fails if the first -argument is not a string or array of strings, and if arg 2 is not convertable -to a number. +* `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 will pass: + The following values pass: + ``` validate_slength("discombobulate",17) validate_slength(["discombobulate","moo"],17) + ``` -The following valueis will not: + 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. -- *Type*: statement + The following values pass: -validate_string ---------------- -Validate that all passed values are string data structures. Abort catalog -compilation if any value fails this check. + ``` + $my_string = "one two" + validate_string($my_string, 'three') + ``` -The following values will pass: + The following values fail, causing compilation to abort: - $my_string = "one two" - validate_string($my_string, 'three') + ``` + validate_string(true) + validate_string([ 'some', 'array' ]) + $undefined = undef + validate_string($undefined) + ``` -The following values will fail, causing compilation to abort: + *Type*: statement - validate_string(true) - validate_string([ 'some', 'array' ]) - $undefined = undef - validate_string($undefined) - - -- *Type*: statement - -values ------- -When given a hash this function will return the values of that hash. +* `values`: When given a hash, this function returns the values of that hash. -*Examples:* + *Examples:* - $hash = { - 'a' => 1, - 'b' => 2, - 'c' => 3, - } - values($hash) + ``` + $hash = { + 'a' => 1, + 'b' => 2, + 'c' => 3, + } + values($hash) + ``` -This example would return: + The example above returns [1,2,3]. - [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: -- *Type*: rvalue + * A single numeric index + * A range in the form of 'start-stop' (eg. 4-9) + * An array combining the above -values_at ---------- -Finds value inside an array based on location. + 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']. -The first argument is the array you want to analyze, and the second element can -be a combination of: + *Type*: rvalue -* A single numeric index -* A range in the form of 'start-stop' (eg. 4-9) -* An array combining the above +* `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 -*Examples*: +##Limitations - values_at(['a','b','c'], 2) +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. -Would return ['c']. +###Version Compatibility - values_at(['a','b','c'], ["0-1"]) - -Would return ['a','b']. +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** - values_at(['a','b','c','d','e'], [0, "2-3"]) +**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). -Would return ['a','c','d']. +##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. -- *Type*: rvalue +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. -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. +You can read the complete module contribution guide on the [Puppet Labs wiki](http://projects.puppetlabs.com/projects/module-site/wiki/Module_contributing). -*Example:* +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). - zip(['1','2','3'],['4','5','6']) +##Contributors -Would result in: +The list of contributors can be found at: https://github.com/puppetlabs/puppetlabs-stdlib/graphs/contributors - ["1", "4"], ["2", "5"], ["3", "6"] -- *Type*: rvalue -*This page autogenerated on 2013-04-11 13:54:25 -0700* diff --git a/stdlib/lib/facter/facter_dot_d.rb b/stdlib/lib/facter/facter_dot_d.rb index e414b2077..b0584370a 100644 --- a/stdlib/lib/facter/facter_dot_d.rb +++ b/stdlib/lib/facter/facter_dot_d.rb @@ -15,7 +15,7 @@ class Facter::Util::DotD require 'yaml' - def initialize(dir="/etc/facts.d", cache_file="/tmp/facts_cache.yml") + def initialize(dir="/etc/facts.d", cache_file=File.join(Puppet[:libdir], "facts_dot_d.cache")) @dir = dir @cache_file = cache_file @cache = nil @@ -23,7 +23,7 @@ def initialize(dir="/etc/facts.d", cache_file="/tmp/facts_cache.yml") end def entries - Dir.entries(@dir).reject{|f| f =~ /^\.|\.ttl$/}.sort.map {|f| File.join(@dir, f) } + Dir.entries(@dir).reject { |f| f =~ /^\.|\.ttl$/ }.sort.map { |f| File.join(@dir, f) } rescue [] end @@ -40,7 +40,7 @@ def fact_type(file) def txt_parser(file) File.readlines(file).each do |line| - if line =~ /^(.+)=(.+)$/ + if line =~ /^([^=]+)=(.+)$/ var = $1; val = $2 Facter.add(var) do @@ -113,7 +113,7 @@ def script_parser(file) def cache_save! cache = load_cache - File.open(@cache_file, "w", 0600) {|f| f.write(YAML.dump(cache)) } + File.open(@cache_file, "w", 0600) { |f| f.write(YAML.dump(cache)) } rescue end diff --git a/stdlib/lib/puppet/functions/type_of.rb b/stdlib/lib/puppet/functions/type_of.rb new file mode 100644 index 000000000..02cdd4db7 --- /dev/null +++ b/stdlib/lib/puppet/functions/type_of.rb @@ -0,0 +1,17 @@ +# 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 diff --git a/stdlib/lib/puppet/parser/functions/basename.rb b/stdlib/lib/puppet/parser/functions/basename.rb new file mode 100644 index 000000000..f7e443847 --- /dev/null +++ b/stdlib/lib/puppet/parser/functions/basename.rb @@ -0,0 +1,34 @@ +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 : diff --git a/stdlib/lib/puppet/parser/functions/bool2num.rb b/stdlib/lib/puppet/parser/functions/bool2num.rb index 9a07a8a11..6ad6cf4e8 100644 --- a/stdlib/lib/puppet/parser/functions/bool2num.rb +++ b/stdlib/lib/puppet/parser/functions/bool2num.rb @@ -14,30 +14,7 @@ module Puppet::Parser::Functions 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 + value = function_str2bool([arguments[0]]) # We have real boolean values as well ... result = value ? 1 : 0 diff --git a/stdlib/lib/puppet/parser/functions/bool2str.rb b/stdlib/lib/puppet/parser/functions/bool2str.rb new file mode 100644 index 000000000..fcd379178 --- /dev/null +++ b/stdlib/lib/puppet/parser/functions/bool2str.rb @@ -0,0 +1,27 @@ +# +# 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 : diff --git a/stdlib/lib/puppet/parser/functions/camelcase.rb b/stdlib/lib/puppet/parser/functions/camelcase.rb new file mode 100644 index 000000000..d7f43f7a7 --- /dev/null +++ b/stdlib/lib/puppet/parser/functions/camelcase.rb @@ -0,0 +1,33 @@ +# +# 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 : diff --git a/stdlib/lib/puppet/parser/functions/capitalize.rb b/stdlib/lib/puppet/parser/functions/capitalize.rb index 640d00b82..98b2d16c9 100644 --- a/stdlib/lib/puppet/parser/functions/capitalize.rb +++ b/stdlib/lib/puppet/parser/functions/capitalize.rb @@ -13,9 +13,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'capitalize(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/chomp.rb b/stdlib/lib/puppet/parser/functions/chomp.rb index 4564a000a..c55841e3c 100644 --- a/stdlib/lib/puppet/parser/functions/chomp.rb +++ b/stdlib/lib/puppet/parser/functions/chomp.rb @@ -14,9 +14,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'chomp(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/chop.rb b/stdlib/lib/puppet/parser/functions/chop.rb index f242af39c..b24ab7856 100644 --- a/stdlib/lib/puppet/parser/functions/chop.rb +++ b/stdlib/lib/puppet/parser/functions/chop.rb @@ -16,9 +16,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'chop(): Requires either an ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/concat.rb b/stdlib/lib/puppet/parser/functions/concat.rb index c86aa0057..618e62d49 100644 --- a/stdlib/lib/puppet/parser/functions/concat.rb +++ b/stdlib/lib/puppet/parser/functions/concat.rb @@ -4,31 +4,35 @@ module Puppet::Parser::Functions newfunction(:concat, :type => :rvalue, :doc => <<-EOS -Appends the contents of array 2 onto array 1. +Appends the contents of multiple arrays into array 1. *Example:* - concat(['1','2','3'],['4','5','6']) + concat(['1','2','3'],['4','5','6'],['7','8','9']) Would result in: - ['1','2','3','4','5','6'] + ['1','2','3','4','5','6','7','8','9'] EOS ) do |arguments| - # Check that 2 arguments have been given ... + # 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 + "given (#{arguments.size} for < 2)") if arguments.size < 2 a = arguments[0] - b = arguments[1] - # Check that both args are arrays. - unless a.is_a?(Array) and b.is_a?(Array) + # 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.concat(b) + result = a + arguments.shift + + arguments.each do |x| + result = result + Array(x) + end return result end diff --git a/stdlib/lib/puppet/parser/functions/delete.rb b/stdlib/lib/puppet/parser/functions/delete.rb index d03a29355..f548b4444 100644 --- a/stdlib/lib/puppet/parser/functions/delete.rb +++ b/stdlib/lib/puppet/parser/functions/delete.rb @@ -17,27 +17,30 @@ module Puppet::Parser::Functions 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 + EOS ) do |arguments| if (arguments.size != 2) then raise(Puppet::ParseError, "delete(): Wrong number of arguments "+ - "given #{arguments.size} for 2.") + "given #{arguments.size} for 2.") end collection = arguments[0].dup - item = arguments[1] - - 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}.") + 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 diff --git a/stdlib/lib/puppet/parser/functions/downcase.rb b/stdlib/lib/puppet/parser/functions/downcase.rb index 4066d210f..040b84f56 100644 --- a/stdlib/lib/puppet/parser/functions/downcase.rb +++ b/stdlib/lib/puppet/parser/functions/downcase.rb @@ -12,9 +12,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'downcase(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/empty.rb b/stdlib/lib/puppet/parser/functions/empty.rb index 80ebb86b8..cca620fae 100644 --- a/stdlib/lib/puppet/parser/functions/empty.rb +++ b/stdlib/lib/puppet/parser/functions/empty.rb @@ -12,9 +12,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, Hash, String].include?(klass) + 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 diff --git a/stdlib/lib/puppet/parser/functions/ensure_packages.rb b/stdlib/lib/puppet/parser/functions/ensure_packages.rb index 1e0f225eb..f1da4aaaa 100644 --- a/stdlib/lib/puppet/parser/functions/ensure_packages.rb +++ b/stdlib/lib/puppet/parser/functions/ensure_packages.rb @@ -5,19 +5,29 @@ 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 != 1 + if arguments.size > 2 or arguments.size == 0 raise(Puppet::ParseError, "ensure_packages(): Wrong number of arguments " + - "given (#{arguments.size} for 1)") + "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, {'ensure' => 'present' } ]) + function_ensure_resource(['package', package_name, defaults ]) } end end diff --git a/stdlib/lib/puppet/parser/functions/ensure_resource.rb b/stdlib/lib/puppet/parser/functions/ensure_resource.rb index 05e5593fc..1ba6a4478 100644 --- a/stdlib/lib/puppet/parser/functions/ensure_resource.rb +++ b/stdlib/lib/puppet/parser/functions/ensure_resource.rb @@ -36,8 +36,9 @@ items.each do |item| Puppet::Parser::Functions.function(:defined_with_params) if function_defined_with_params(["#{type}[#{item}]", params]) - Puppet.debug("Resource #{type}[#{item}] not created because it already exists") + 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 diff --git a/stdlib/lib/puppet/parser/functions/floor.rb b/stdlib/lib/puppet/parser/functions/floor.rb index a40192349..9a6f014d7 100644 --- a/stdlib/lib/puppet/parser/functions/floor.rb +++ b/stdlib/lib/puppet/parser/functions/floor.rb @@ -8,7 +8,12 @@ module Puppet::Parser::Functions raise(Puppet::ParseError, "floor(): Wrong number of arguments " + "given (#{arguments.size} for 1)") if arguments.size != 1 - arg = arguments[0] + 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 diff --git a/stdlib/lib/puppet/parser/functions/fqdn_rotate.rb b/stdlib/lib/puppet/parser/functions/fqdn_rotate.rb index 655820605..cf22d3681 100644 --- a/stdlib/lib/puppet/parser/functions/fqdn_rotate.rb +++ b/stdlib/lib/puppet/parser/functions/fqdn_rotate.rb @@ -12,10 +12,9 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class require 'digest/md5' - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'fqdn_rotate(): Requires either ' + 'array or string to work with') end @@ -32,8 +31,20 @@ module Puppet::Parser::Functions elements = result.size - srand(Digest::MD5.hexdigest([lookupvar('::fqdn'),arguments].join(':')).hex) - rand(elements).times { + 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 } diff --git a/stdlib/lib/puppet/parser/functions/getvar.rb b/stdlib/lib/puppet/parser/functions/getvar.rb index 162114995..fb336b6ac 100644 --- a/stdlib/lib/puppet/parser/functions/getvar.rb +++ b/stdlib/lib/puppet/parser/functions/getvar.rb @@ -19,7 +19,10 @@ module Puppet::Parser::Functions raise Puppet::ParseError, ("getvar(): wrong number of arguments (#{args.length}; must be 1)") end - self.lookupvar("#{args[0]}") + begin + self.lookupvar("#{args[0]}") + rescue Puppet::ParseError # Eat the exception if strict_variables = true is set + end end diff --git a/stdlib/lib/puppet/parser/functions/has_interface_with.rb b/stdlib/lib/puppet/parser/functions/has_interface_with.rb index 7f150a717..36915246d 100644 --- a/stdlib/lib/puppet/parser/functions/has_interface_with.rb +++ b/stdlib/lib/puppet/parser/functions/has_interface_with.rb @@ -25,7 +25,7 @@ module Puppet::Parser::Functions interfaces = lookupvar('interfaces') # If we do not have any interfaces, then there are no requested attributes - return false if (interfaces == :undefined) + return false if (interfaces == :undefined || interfaces.nil?) interfaces = interfaces.split(',') @@ -35,13 +35,29 @@ module Puppet::Parser::Functions kind, value = args - if lookupvar(kind) == value + # 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| - if value == lookupvar("#{kind}_#{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 diff --git a/stdlib/lib/puppet/parser/functions/is_domain_name.rb b/stdlib/lib/puppet/parser/functions/is_domain_name.rb index 5826dc0d9..b3fee965a 100644 --- a/stdlib/lib/puppet/parser/functions/is_domain_name.rb +++ b/stdlib/lib/puppet/parser/functions/is_domain_name.rb @@ -20,6 +20,9 @@ module Puppet::Parser::Functions label_min_length=1 label_max_length=63 + # Only allow string types + return false unless domain.is_a?(String) + # Allow ".", it is the top level domain return true if domain == '.' diff --git a/stdlib/lib/puppet/parser/functions/is_float.rb b/stdlib/lib/puppet/parser/functions/is_float.rb index 911f3c2dc..a2da94385 100644 --- a/stdlib/lib/puppet/parser/functions/is_float.rb +++ b/stdlib/lib/puppet/parser/functions/is_float.rb @@ -15,6 +15,9 @@ module Puppet::Parser::Functions 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 diff --git a/stdlib/lib/puppet/parser/functions/is_function_available.rb b/stdlib/lib/puppet/parser/functions/is_function_available.rb index 6cbd35c3d..6da82c8c1 100644 --- a/stdlib/lib/puppet/parser/functions/is_function_available.rb +++ b/stdlib/lib/puppet/parser/functions/is_function_available.rb @@ -15,6 +15,9 @@ module Puppet::Parser::Functions "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 diff --git a/stdlib/lib/puppet/parser/functions/lstrip.rb b/stdlib/lib/puppet/parser/functions/lstrip.rb index 3a64de337..624e4c846 100644 --- a/stdlib/lib/puppet/parser/functions/lstrip.rb +++ b/stdlib/lib/puppet/parser/functions/lstrip.rb @@ -12,9 +12,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'lstrip(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/member.rb b/stdlib/lib/puppet/parser/functions/member.rb index 43d76affd..88609ce5f 100644 --- a/stdlib/lib/puppet/parser/functions/member.rb +++ b/stdlib/lib/puppet/parser/functions/member.rb @@ -8,6 +8,7 @@ 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:* @@ -15,9 +16,17 @@ module Puppet::Parser::Functions 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| @@ -30,12 +39,21 @@ module Puppet::Parser::Functions raise(Puppet::ParseError, 'member(): Requires array to work with') end - item = arguments[1] + 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.empty? + 'to search for within array given') if item.respond_to?('empty?') && item.empty? - result = array.include?(item) + result = (item - array).empty? return result end diff --git a/stdlib/lib/puppet/parser/functions/private.rb b/stdlib/lib/puppet/parser/functions/private.rb new file mode 100644 index 000000000..60210d335 --- /dev/null +++ b/stdlib/lib/puppet/parser/functions/private.rb @@ -0,0 +1,29 @@ +# +# private.rb +# + +module Puppet::Parser::Functions + newfunction(: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, "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 diff --git a/stdlib/lib/puppet/parser/functions/range.rb b/stdlib/lib/puppet/parser/functions/range.rb index ffbdf8463..49fba21c8 100644 --- a/stdlib/lib/puppet/parser/functions/range.rb +++ b/stdlib/lib/puppet/parser/functions/range.rb @@ -65,21 +65,21 @@ module Puppet::Parser::Functions 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 + # 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 + 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 ... + result = range.step(step).collect { |i| i } # Get them all ... Pokemon ... return result end diff --git a/stdlib/lib/puppet/parser/functions/reverse.rb b/stdlib/lib/puppet/parser/functions/reverse.rb index fe048690c..7f1018f67 100644 --- a/stdlib/lib/puppet/parser/functions/reverse.rb +++ b/stdlib/lib/puppet/parser/functions/reverse.rb @@ -12,9 +12,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'reverse(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/rstrip.rb b/stdlib/lib/puppet/parser/functions/rstrip.rb index 29b099820..0cf8d222c 100644 --- a/stdlib/lib/puppet/parser/functions/rstrip.rb +++ b/stdlib/lib/puppet/parser/functions/rstrip.rb @@ -12,9 +12,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'rstrip(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/shuffle.rb b/stdlib/lib/puppet/parser/functions/shuffle.rb index 18134ab63..30c663dbe 100644 --- a/stdlib/lib/puppet/parser/functions/shuffle.rb +++ b/stdlib/lib/puppet/parser/functions/shuffle.rb @@ -12,9 +12,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'shuffle(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/strip.rb b/stdlib/lib/puppet/parser/functions/strip.rb index 5f4630d7d..3fac47d53 100644 --- a/stdlib/lib/puppet/parser/functions/strip.rb +++ b/stdlib/lib/puppet/parser/functions/strip.rb @@ -19,9 +19,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'strip(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/swapcase.rb b/stdlib/lib/puppet/parser/functions/swapcase.rb index b9e663253..eb7fe137d 100644 --- a/stdlib/lib/puppet/parser/functions/swapcase.rb +++ b/stdlib/lib/puppet/parser/functions/swapcase.rb @@ -18,9 +18,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'swapcase(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/to_bytes.rb b/stdlib/lib/puppet/parser/functions/to_bytes.rb index 8ff73d10b..df490ea8c 100644 --- a/stdlib/lib/puppet/parser/functions/to_bytes.rb +++ b/stdlib/lib/puppet/parser/functions/to_bytes.rb @@ -2,6 +2,8 @@ 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| @@ -21,7 +23,8 @@ module Puppet::Parser::Functions 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 'E' then return (value*(1<<50)).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 diff --git a/stdlib/lib/puppet/parser/functions/type.rb b/stdlib/lib/puppet/parser/functions/type.rb index 8d85f1158..016529b03 100644 --- a/stdlib/lib/puppet/parser/functions/type.rb +++ b/stdlib/lib/puppet/parser/functions/type.rb @@ -4,46 +4,15 @@ 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 + 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 |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 ... + ) do |args| - # 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 + 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 - - 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 + function_type3x(args + [false]) end end diff --git a/stdlib/lib/puppet/parser/functions/type3x.rb b/stdlib/lib/puppet/parser/functions/type3x.rb new file mode 100644 index 000000000..0800b4a3e --- /dev/null +++ b/stdlib/lib/puppet/parser/functions/type3x.rb @@ -0,0 +1,51 @@ +# +# 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 : diff --git a/stdlib/lib/puppet/parser/functions/unique.rb b/stdlib/lib/puppet/parser/functions/unique.rb index 8844a7418..cf770f3b4 100644 --- a/stdlib/lib/puppet/parser/functions/unique.rb +++ b/stdlib/lib/puppet/parser/functions/unique.rb @@ -28,9 +28,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'unique(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/upcase.rb b/stdlib/lib/puppet/parser/functions/upcase.rb index fe6cadc3c..4302b29e7 100644 --- a/stdlib/lib/puppet/parser/functions/upcase.rb +++ b/stdlib/lib/puppet/parser/functions/upcase.rb @@ -20,9 +20,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'upcase(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/uriescape.rb b/stdlib/lib/puppet/parser/functions/uriescape.rb index 0d81de5d1..a486eee50 100644 --- a/stdlib/lib/puppet/parser/functions/uriescape.rb +++ b/stdlib/lib/puppet/parser/functions/uriescape.rb @@ -14,9 +14,8 @@ module Puppet::Parser::Functions "given (#{arguments.size} for 1)") if arguments.size < 1 value = arguments[0] - klass = value.class - unless [Array, String].include?(klass) + unless value.is_a?(Array) || value.is_a?(String) raise(Puppet::ParseError, 'uriescape(): Requires either ' + 'array or string to work with') end diff --git a/stdlib/lib/puppet/parser/functions/validate_absolute_path.rb b/stdlib/lib/puppet/parser/functions/validate_absolute_path.rb index fe279744e..b69668096 100644 --- a/stdlib/lib/puppet/parser/functions/validate_absolute_path.rb +++ b/stdlib/lib/puppet/parser/functions/validate_absolute_path.rb @@ -5,15 +5,20 @@ module Puppet::Parser::Functions The following values will pass: - $my_path = "C:/Program Files (x86)/Puppet Labs/Puppet" + $my_path = 'C:/Program Files (x86)/Puppet Labs/Puppet' validate_absolute_path($my_path) - $my_path2 = "/var/lib/puppet" + $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 @@ -28,28 +33,36 @@ module Puppet::Parser::Functions end args.each do |arg| - # 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?(arg, :posix) or Puppet::Util.absolute_path?(arg, :windows) - raise Puppet::ParseError, ("#{arg.inspect} is not an absolute path.") + # 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 - 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 = (!!(arg =~ regexes[:posix])) || (!!(arg =~ regexes[:windows])) - rval or raise Puppet::ParseError, ("#{arg.inspect} is not an absolute path.") end end end diff --git a/stdlib/lib/puppet/parser/functions/validate_augeas.rb b/stdlib/lib/puppet/parser/functions/validate_augeas.rb index 154d66091..4ea4fe070 100644 --- a/stdlib/lib/puppet/parser/functions/validate_augeas.rb +++ b/stdlib/lib/puppet/parser/functions/validate_augeas.rb @@ -1,3 +1,5 @@ +require 'tempfile' + module Puppet::Parser::Functions newfunction(:validate_augeas, :doc => <<-'ENDHEREDOC') do |args| Perform validation of a string using an Augeas lens diff --git a/stdlib/lib/puppet/parser/functions/validate_cmd.rb b/stdlib/lib/puppet/parser/functions/validate_cmd.rb index 2ebe91cf7..5df3c6094 100644 --- a/stdlib/lib/puppet/parser/functions/validate_cmd.rb +++ b/stdlib/lib/puppet/parser/functions/validate_cmd.rb @@ -1,13 +1,14 @@ 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 file as last argument. If the command, launched against - a tempfile containing the passed string, returns a non-null value, - compilation will abort with a parse error. + 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. @@ -16,8 +17,12 @@ module Puppet::Parser::Functions 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)") @@ -33,14 +38,24 @@ module Puppet::Parser::Functions 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("#{checkscript} #{tmpfile.path}") + Puppet::Util::Execution.execute(check_with_correct_location) else - Puppet::Util.execute("#{checkscript} #{tmpfile.path}") + 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 diff --git a/stdlib/lib/puppet/parser/functions/validate_string.rb b/stdlib/lib/puppet/parser/functions/validate_string.rb index e667794a6..c841f6abb 100644 --- a/stdlib/lib/puppet/parser/functions/validate_string.rb +++ b/stdlib/lib/puppet/parser/functions/validate_string.rb @@ -13,9 +13,14 @@ module Puppet::Parser::Functions validate_string(true) validate_string([ 'some', 'array' ]) - $undefined = undef - validate_string($undefined) - + + 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 diff --git a/stdlib/lib/puppet/parser/functions/values_at.rb b/stdlib/lib/puppet/parser/functions/values_at.rb index d3e69d97f..f350f5391 100644 --- a/stdlib/lib/puppet/parser/functions/values_at.rb +++ b/stdlib/lib/puppet/parser/functions/values_at.rb @@ -49,6 +49,7 @@ module Puppet::Parser::Functions 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 diff --git a/stdlib/lib/puppet/parser/functions/zip.rb b/stdlib/lib/puppet/parser/functions/zip.rb index 2b56e9ca0..3074f282b 100644 --- a/stdlib/lib/puppet/parser/functions/zip.rb +++ b/stdlib/lib/puppet/parser/functions/zip.rb @@ -27,33 +27,7 @@ module Puppet::Parser::Functions 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 + flatten = function_str2bool([arguments[2]]) if arguments[2] result = a.zip(b) result = flatten ? result.flatten : result diff --git a/stdlib/lib/puppet/provider/file_line/ruby.rb b/stdlib/lib/puppet/provider/file_line/ruby.rb index 94e7fac91..ae1a8b3db 100644 --- a/stdlib/lib/puppet/provider/file_line/ruby.rb +++ b/stdlib/lib/puppet/provider/file_line/ruby.rb @@ -34,7 +34,7 @@ def lines def handle_create_with_match() regex = resource[:match] ? Regexp.new(resource[:match]) : nil - match_count = lines.select { |l| regex.match(l) }.size + 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 @@ -51,9 +51,7 @@ def handle_create_with_match() def handle_create_with_after regex = Regexp.new(resource[:after]) - - count = lines.count {|l| l.match(regex)} - + count = count_matches(regex) case count when 1 # find the line to put our line after File.open(resource[:path], 'w') do |fh| @@ -71,6 +69,10 @@ def handle_create_with_after end end + def count_matches(regex) + lines.select{|l| l.match(regex)}.size + end + ## # append the line to the file. # diff --git a/stdlib/lib/puppet/type/file_line.rb b/stdlib/lib/puppet/type/file_line.rb index 323fc4c9c..df263e6a7 100644 --- a/stdlib/lib/puppet/type/file_line.rb +++ b/stdlib/lib/puppet/type/file_line.rb @@ -21,6 +21,9 @@ In this example, Puppet will ensure both of the specified lines are contained in the file /etc/sudoers. + **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 @@ -68,12 +71,5 @@ unless self[:line] and self[:path] raise(Puppet::Error, "Both line and path are required attributes") end - - if (self[:match]) - unless Regexp.new(self[:match]).match(self[:line]) - raise(Puppet::Error, "When providing a 'match' parameter, the value must be a regex that matches against the value of your 'line' parameter") - end - end - end end diff --git a/stdlib/metadata.json b/stdlib/metadata.json index 5e9fb0edc..27def9c08 100644 --- a/stdlib/metadata.json +++ b/stdlib/metadata.json @@ -1,11 +1,20 @@ { + "name": "puppetlabs-stdlib", + "version": "4.5.1", + "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" + "6", + "7" ] }, { @@ -13,7 +22,8 @@ "operatingsystemrelease": [ "4", "5", - "6" + "6", + "7" ] }, { @@ -21,7 +31,8 @@ "operatingsystemrelease": [ "4", "5", - "6" + "6", + "7" ] }, { @@ -29,13 +40,16 @@ "operatingsystemrelease": [ "4", "5", - "6" + "6", + "7" ] }, { "operatingsystem": "SLES", "operatingsystemrelease": [ - "11 SP1" + "10 SP4", + "11 SP1", + "12" ] }, { @@ -49,7 +63,8 @@ "operatingsystem": "Ubuntu", "operatingsystemrelease": [ "10.04", - "12.04" + "12.04", + "14.04" ] }, { @@ -84,22 +99,15 @@ "requirements": [ { "name": "pe", - "version_requirement": "3.2.x" + "version_requirement": "3.x" }, { "name": "puppet", "version_requirement": ">=2.7.20 <4.0.0" } ], - "name": "puppetlabs-stdlib", - "version": "3.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", "dependencies": [ - + ] } diff --git a/stdlib/spec/acceptance/abs_spec.rb b/stdlib/spec/acceptance/abs_spec.rb new file mode 100755 index 000000000..6e41e2fde --- /dev/null +++ b/stdlib/spec/acceptance/abs_spec.rb @@ -0,0 +1,30 @@ +#! /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 diff --git a/stdlib/spec/acceptance/any2array_spec.rb b/stdlib/spec/acceptance/any2array_spec.rb new file mode 100755 index 000000000..18ea4cd9b --- /dev/null +++ b/stdlib/spec/acceptance/any2array_spec.rb @@ -0,0 +1,49 @@ +#! /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 diff --git a/stdlib/spec/acceptance/base64_spec.rb b/stdlib/spec/acceptance/base64_spec.rb new file mode 100755 index 000000000..97e1738ef --- /dev/null +++ b/stdlib/spec/acceptance/base64_spec.rb @@ -0,0 +1,18 @@ +#! /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 diff --git a/stdlib/spec/acceptance/bool2num_spec.rb b/stdlib/spec/acceptance/bool2num_spec.rb new file mode 100755 index 000000000..52ff75bcf --- /dev/null +++ b/stdlib/spec/acceptance/bool2num_spec.rb @@ -0,0 +1,34 @@ +#! /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 diff --git a/stdlib/spec/acceptance/build_csv.rb b/stdlib/spec/acceptance/build_csv.rb new file mode 100755 index 000000000..62ecbf13a --- /dev/null +++ b/stdlib/spec/acceptance/build_csv.rb @@ -0,0 +1,83 @@ +#!/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 diff --git a/stdlib/spec/acceptance/capitalize_spec.rb b/stdlib/spec/acceptance/capitalize_spec.rb new file mode 100755 index 000000000..e5e7b7bf8 --- /dev/null +++ b/stdlib/spec/acceptance/capitalize_spec.rb @@ -0,0 +1,33 @@ +#! /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 diff --git a/stdlib/spec/acceptance/chomp_spec.rb b/stdlib/spec/acceptance/chomp_spec.rb new file mode 100755 index 000000000..f6c15956e --- /dev/null +++ b/stdlib/spec/acceptance/chomp_spec.rb @@ -0,0 +1,21 @@ +#! /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 diff --git a/stdlib/spec/acceptance/chop_spec.rb b/stdlib/spec/acceptance/chop_spec.rb new file mode 100755 index 000000000..a16a71026 --- /dev/null +++ b/stdlib/spec/acceptance/chop_spec.rb @@ -0,0 +1,45 @@ +#! /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 diff --git a/stdlib/spec/acceptance/concat_spec.rb b/stdlib/spec/acceptance/concat_spec.rb new file mode 100755 index 000000000..06b649f19 --- /dev/null +++ b/stdlib/spec/acceptance/concat_spec.rb @@ -0,0 +1,40 @@ +#! /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 diff --git a/stdlib/spec/acceptance/count_spec.rb b/stdlib/spec/acceptance/count_spec.rb new file mode 100755 index 000000000..fe7ca9dcf --- /dev/null +++ b/stdlib/spec/acceptance/count_spec.rb @@ -0,0 +1,30 @@ +#! /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 diff --git a/stdlib/spec/acceptance/deep_merge_spec.rb b/stdlib/spec/acceptance/deep_merge_spec.rb new file mode 100755 index 000000000..c0f9b126d --- /dev/null +++ b/stdlib/spec/acceptance/deep_merge_spec.rb @@ -0,0 +1,20 @@ +#! /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 diff --git a/stdlib/spec/acceptance/defined_with_params_spec.rb b/stdlib/spec/acceptance/defined_with_params_spec.rb new file mode 100755 index 000000000..fc544508b --- /dev/null +++ b/stdlib/spec/acceptance/defined_with_params_spec.rb @@ -0,0 +1,22 @@ +#! /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 diff --git a/stdlib/spec/acceptance/delete_at_spec.rb b/stdlib/spec/acceptance/delete_at_spec.rb new file mode 100755 index 000000000..db0c01f74 --- /dev/null +++ b/stdlib/spec/acceptance/delete_at_spec.rb @@ -0,0 +1,19 @@ +#! /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 diff --git a/stdlib/spec/acceptance/delete_spec.rb b/stdlib/spec/acceptance/delete_spec.rb new file mode 100755 index 000000000..a28604cea --- /dev/null +++ b/stdlib/spec/acceptance/delete_spec.rb @@ -0,0 +1,19 @@ +#! /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 diff --git a/stdlib/spec/acceptance/delete_undef_values_spec.rb b/stdlib/spec/acceptance/delete_undef_values_spec.rb new file mode 100755 index 000000000..b7eda1926 --- /dev/null +++ b/stdlib/spec/acceptance/delete_undef_values_spec.rb @@ -0,0 +1,19 @@ +#! /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 diff --git a/stdlib/spec/acceptance/delete_values_spec.rb b/stdlib/spec/acceptance/delete_values_spec.rb new file mode 100755 index 000000000..6d2369c3e --- /dev/null +++ b/stdlib/spec/acceptance/delete_values_spec.rb @@ -0,0 +1,25 @@ +#! /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 diff --git a/stdlib/spec/acceptance/difference_spec.rb b/stdlib/spec/acceptance/difference_spec.rb new file mode 100755 index 000000000..2fae5c432 --- /dev/null +++ b/stdlib/spec/acceptance/difference_spec.rb @@ -0,0 +1,26 @@ +#! /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 diff --git a/stdlib/spec/acceptance/dirname_spec.rb b/stdlib/spec/acceptance/dirname_spec.rb new file mode 100755 index 000000000..97913ddb0 --- /dev/null +++ b/stdlib/spec/acceptance/dirname_spec.rb @@ -0,0 +1,42 @@ +#! /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 diff --git a/stdlib/spec/acceptance/downcase_spec.rb b/stdlib/spec/acceptance/downcase_spec.rb new file mode 100755 index 000000000..bc4e70692 --- /dev/null +++ b/stdlib/spec/acceptance/downcase_spec.rb @@ -0,0 +1,39 @@ +#! /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 diff --git a/stdlib/spec/acceptance/empty_spec.rb b/stdlib/spec/acceptance/empty_spec.rb new file mode 100755 index 000000000..8b46aacda --- /dev/null +++ b/stdlib/spec/acceptance/empty_spec.rb @@ -0,0 +1,39 @@ +#! /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 diff --git a/stdlib/spec/acceptance/ensure_packages_spec.rb b/stdlib/spec/acceptance/ensure_packages_spec.rb new file mode 100755 index 000000000..aedcfb55d --- /dev/null +++ b/stdlib/spec/acceptance/ensure_packages_spec.rb @@ -0,0 +1,22 @@ +#! /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 diff --git a/stdlib/spec/acceptance/ensure_resource_spec.rb b/stdlib/spec/acceptance/ensure_resource_spec.rb new file mode 100755 index 000000000..1cee53db9 --- /dev/null +++ b/stdlib/spec/acceptance/ensure_resource_spec.rb @@ -0,0 +1,22 @@ +#! /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 diff --git a/stdlib/spec/acceptance/flatten_spec.rb b/stdlib/spec/acceptance/flatten_spec.rb new file mode 100755 index 000000000..c4d66e046 --- /dev/null +++ b/stdlib/spec/acceptance/flatten_spec.rb @@ -0,0 +1,39 @@ +#! /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 diff --git a/stdlib/spec/acceptance/floor_spec.rb b/stdlib/spec/acceptance/floor_spec.rb new file mode 100755 index 000000000..0dcdad9c2 --- /dev/null +++ b/stdlib/spec/acceptance/floor_spec.rb @@ -0,0 +1,39 @@ +#! /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 diff --git a/stdlib/spec/acceptance/fqdn_rotate_spec.rb b/stdlib/spec/acceptance/fqdn_rotate_spec.rb new file mode 100755 index 000000000..753068bfe --- /dev/null +++ b/stdlib/spec/acceptance/fqdn_rotate_spec.rb @@ -0,0 +1,47 @@ +#! /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 diff --git a/stdlib/spec/acceptance/get_module_path_spec.rb b/stdlib/spec/acceptance/get_module_path_spec.rb new file mode 100755 index 000000000..6ac690c16 --- /dev/null +++ b/stdlib/spec/acceptance/get_module_path_spec.rb @@ -0,0 +1,27 @@ +#! /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 diff --git a/stdlib/spec/acceptance/getparam_spec.rb b/stdlib/spec/acceptance/getparam_spec.rb new file mode 100755 index 000000000..b1a677eca --- /dev/null +++ b/stdlib/spec/acceptance/getparam_spec.rb @@ -0,0 +1,24 @@ +#! /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 diff --git a/stdlib/spec/acceptance/getvar_spec.rb b/stdlib/spec/acceptance/getvar_spec.rb new file mode 100755 index 000000000..333c467f6 --- /dev/null +++ b/stdlib/spec/acceptance/getvar_spec.rb @@ -0,0 +1,26 @@ +#! /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 diff --git a/stdlib/spec/acceptance/grep_spec.rb b/stdlib/spec/acceptance/grep_spec.rb new file mode 100755 index 000000000..b39d48ecb --- /dev/null +++ b/stdlib/spec/acceptance/grep_spec.rb @@ -0,0 +1,26 @@ +#! /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 diff --git a/stdlib/spec/acceptance/has_interface_with_spec.rb b/stdlib/spec/acceptance/has_interface_with_spec.rb new file mode 100755 index 000000000..959019304 --- /dev/null +++ b/stdlib/spec/acceptance/has_interface_with_spec.rb @@ -0,0 +1,54 @@ +#! /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 diff --git a/stdlib/spec/acceptance/has_ip_address_spec.rb b/stdlib/spec/acceptance/has_ip_address_spec.rb new file mode 100755 index 000000000..149a10dc9 --- /dev/null +++ b/stdlib/spec/acceptance/has_ip_address_spec.rb @@ -0,0 +1,33 @@ +#! /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 diff --git a/stdlib/spec/acceptance/has_ip_network_spec.rb b/stdlib/spec/acceptance/has_ip_network_spec.rb new file mode 100755 index 000000000..7d2f34ed5 --- /dev/null +++ b/stdlib/spec/acceptance/has_ip_network_spec.rb @@ -0,0 +1,33 @@ +#! /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 diff --git a/stdlib/spec/acceptance/has_key_spec.rb b/stdlib/spec/acceptance/has_key_spec.rb new file mode 100755 index 000000000..c8557cbeb --- /dev/null +++ b/stdlib/spec/acceptance/has_key_spec.rb @@ -0,0 +1,41 @@ +#! /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 diff --git a/stdlib/spec/acceptance/hash_spec.rb b/stdlib/spec/acceptance/hash_spec.rb new file mode 100755 index 000000000..ed53834be --- /dev/null +++ b/stdlib/spec/acceptance/hash_spec.rb @@ -0,0 +1,26 @@ +#! /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 diff --git a/stdlib/spec/acceptance/intersection_spec.rb b/stdlib/spec/acceptance/intersection_spec.rb new file mode 100755 index 000000000..66b865297 --- /dev/null +++ b/stdlib/spec/acceptance/intersection_spec.rb @@ -0,0 +1,27 @@ +#! /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 diff --git a/stdlib/spec/acceptance/is_array_spec.rb b/stdlib/spec/acceptance/is_array_spec.rb new file mode 100755 index 000000000..9c6bad735 --- /dev/null +++ b/stdlib/spec/acceptance/is_array_spec.rb @@ -0,0 +1,67 @@ +#! /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 diff --git a/stdlib/spec/acceptance/is_bool_spec.rb b/stdlib/spec/acceptance/is_bool_spec.rb new file mode 100755 index 000000000..60079f95e --- /dev/null +++ b/stdlib/spec/acceptance/is_bool_spec.rb @@ -0,0 +1,81 @@ +#! /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 diff --git a/stdlib/spec/acceptance/is_domain_name_spec.rb b/stdlib/spec/acceptance/is_domain_name_spec.rb new file mode 100755 index 000000000..e0f03fa87 --- /dev/null +++ b/stdlib/spec/acceptance/is_domain_name_spec.rb @@ -0,0 +1,83 @@ +#! /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 diff --git a/stdlib/spec/acceptance/is_float_spec.rb b/stdlib/spec/acceptance/is_float_spec.rb new file mode 100755 index 000000000..338ba58d4 --- /dev/null +++ b/stdlib/spec/acceptance/is_float_spec.rb @@ -0,0 +1,86 @@ +#! /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 diff --git a/stdlib/spec/acceptance/is_function_available_spec.rb b/stdlib/spec/acceptance/is_function_available_spec.rb new file mode 100755 index 000000000..2b5dd6d17 --- /dev/null +++ b/stdlib/spec/acceptance/is_function_available_spec.rb @@ -0,0 +1,58 @@ +#! /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 diff --git a/stdlib/spec/acceptance/is_hash_spec.rb b/stdlib/spec/acceptance/is_hash_spec.rb new file mode 100755 index 000000000..2ef310abc --- /dev/null +++ b/stdlib/spec/acceptance/is_hash_spec.rb @@ -0,0 +1,63 @@ +#! /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 diff --git a/stdlib/spec/acceptance/is_integer_spec.rb b/stdlib/spec/acceptance/is_integer_spec.rb new file mode 100755 index 000000000..bf6902b90 --- /dev/null +++ b/stdlib/spec/acceptance/is_integer_spec.rb @@ -0,0 +1,95 @@ +#! /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 diff --git a/stdlib/spec/acceptance/is_ip_address_spec.rb b/stdlib/spec/acceptance/is_ip_address_spec.rb new file mode 100755 index 000000000..ed7a85439 --- /dev/null +++ b/stdlib/spec/acceptance/is_ip_address_spec.rb @@ -0,0 +1,80 @@ +#! /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 diff --git a/stdlib/spec/acceptance/is_mac_address_spec.rb b/stdlib/spec/acceptance/is_mac_address_spec.rb new file mode 100755 index 000000000..a2c892f43 --- /dev/null +++ b/stdlib/spec/acceptance/is_mac_address_spec.rb @@ -0,0 +1,38 @@ +#! /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 diff --git a/stdlib/spec/acceptance/is_numeric_spec.rb b/stdlib/spec/acceptance/is_numeric_spec.rb new file mode 100755 index 000000000..21c898841 --- /dev/null +++ b/stdlib/spec/acceptance/is_numeric_spec.rb @@ -0,0 +1,95 @@ +#! /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 diff --git a/stdlib/spec/acceptance/is_string_spec.rb b/stdlib/spec/acceptance/is_string_spec.rb new file mode 100755 index 000000000..94d8e9678 --- /dev/null +++ b/stdlib/spec/acceptance/is_string_spec.rb @@ -0,0 +1,102 @@ +#! /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 diff --git a/stdlib/spec/acceptance/join_keys_to_values_spec.rb b/stdlib/spec/acceptance/join_keys_to_values_spec.rb new file mode 100755 index 000000000..70493fd5a --- /dev/null +++ b/stdlib/spec/acceptance/join_keys_to_values_spec.rb @@ -0,0 +1,24 @@ +#! /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 diff --git a/stdlib/spec/acceptance/join_spec.rb b/stdlib/spec/acceptance/join_spec.rb new file mode 100755 index 000000000..5397ce2c8 --- /dev/null +++ b/stdlib/spec/acceptance/join_spec.rb @@ -0,0 +1,26 @@ +#! /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 diff --git a/stdlib/spec/acceptance/keys_spec.rb b/stdlib/spec/acceptance/keys_spec.rb new file mode 100755 index 000000000..176918e91 --- /dev/null +++ b/stdlib/spec/acceptance/keys_spec.rb @@ -0,0 +1,23 @@ +#! /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 diff --git a/stdlib/spec/acceptance/loadyaml_spec.rb b/stdlib/spec/acceptance/loadyaml_spec.rb new file mode 100644 index 000000000..1e910a978 --- /dev/null +++ b/stdlib/spec/acceptance/loadyaml_spec.rb @@ -0,0 +1,33 @@ +#! /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 diff --git a/stdlib/spec/acceptance/lstrip_spec.rb b/stdlib/spec/acceptance/lstrip_spec.rb new file mode 100755 index 000000000..3dc952fbc --- /dev/null +++ b/stdlib/spec/acceptance/lstrip_spec.rb @@ -0,0 +1,34 @@ +#! /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 diff --git a/stdlib/spec/acceptance/max_spec.rb b/stdlib/spec/acceptance/max_spec.rb new file mode 100755 index 000000000..f04e3d283 --- /dev/null +++ b/stdlib/spec/acceptance/max_spec.rb @@ -0,0 +1,20 @@ +#! /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 diff --git a/stdlib/spec/acceptance/member_spec.rb b/stdlib/spec/acceptance/member_spec.rb new file mode 100755 index 000000000..fe75a0782 --- /dev/null +++ b/stdlib/spec/acceptance/member_spec.rb @@ -0,0 +1,54 @@ +#! /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 diff --git a/stdlib/spec/acceptance/merge_spec.rb b/stdlib/spec/acceptance/merge_spec.rb new file mode 100755 index 000000000..227b99429 --- /dev/null +++ b/stdlib/spec/acceptance/merge_spec.rb @@ -0,0 +1,23 @@ +#! /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 diff --git a/stdlib/spec/acceptance/min_spec.rb b/stdlib/spec/acceptance/min_spec.rb new file mode 100755 index 000000000..509092d3c --- /dev/null +++ b/stdlib/spec/acceptance/min_spec.rb @@ -0,0 +1,20 @@ +#! /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 diff --git a/stdlib/spec/acceptance/nodesets/centos-59-x64.yml b/stdlib/spec/acceptance/nodesets/centos-59-x64.yml new file mode 100644 index 000000000..2ad90b86a --- /dev/null +++ b/stdlib/spec/acceptance/nodesets/centos-59-x64.yml @@ -0,0 +1,10 @@ +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 diff --git a/stdlib/spec/acceptance/nodesets/centos-6-vcloud.yml b/stdlib/spec/acceptance/nodesets/centos-6-vcloud.yml new file mode 100644 index 000000000..ca9c1d329 --- /dev/null +++ b/stdlib/spec/acceptance/nodesets/centos-6-vcloud.yml @@ -0,0 +1,15 @@ +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/ diff --git a/stdlib/spec/acceptance/nodesets/default.yml b/stdlib/spec/acceptance/nodesets/default.yml deleted file mode 120000 index 2719644a6..000000000 --- a/stdlib/spec/acceptance/nodesets/default.yml +++ /dev/null @@ -1 +0,0 @@ -centos-64-x64.yml \ No newline at end of file diff --git a/stdlib/spec/acceptance/nodesets/default.yml b/stdlib/spec/acceptance/nodesets/default.yml new file mode 100644 index 000000000..4e2cb809e --- /dev/null +++ b/stdlib/spec/acceptance/nodesets/default.yml @@ -0,0 +1,10 @@ +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 diff --git a/stdlib/spec/acceptance/nodesets/ubuntu-server-1404-x64.yml b/stdlib/spec/acceptance/nodesets/ubuntu-server-1404-x64.yml new file mode 100644 index 000000000..cba1cd04c --- /dev/null +++ b/stdlib/spec/acceptance/nodesets/ubuntu-server-1404-x64.yml @@ -0,0 +1,11 @@ +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 diff --git a/stdlib/spec/acceptance/nodesets/windows-2003-i386.yml b/stdlib/spec/acceptance/nodesets/windows-2003-i386.yml new file mode 100644 index 000000000..47dadbd52 --- /dev/null +++ b/stdlib/spec/acceptance/nodesets/windows-2003-i386.yml @@ -0,0 +1,26 @@ +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/ diff --git a/stdlib/spec/acceptance/nodesets/windows-2003-x86_64.yml b/stdlib/spec/acceptance/nodesets/windows-2003-x86_64.yml new file mode 100644 index 000000000..6a884bc9f --- /dev/null +++ b/stdlib/spec/acceptance/nodesets/windows-2003-x86_64.yml @@ -0,0 +1,26 @@ +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/ diff --git a/stdlib/spec/acceptance/nodesets/windows-2008-x86_64.yml b/stdlib/spec/acceptance/nodesets/windows-2008-x86_64.yml new file mode 100644 index 000000000..ae3c11dd1 --- /dev/null +++ b/stdlib/spec/acceptance/nodesets/windows-2008-x86_64.yml @@ -0,0 +1,26 @@ +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/ diff --git a/stdlib/spec/acceptance/nodesets/windows-2008r2-x86_64.yml b/stdlib/spec/acceptance/nodesets/windows-2008r2-x86_64.yml new file mode 100644 index 000000000..63923ac10 --- /dev/null +++ b/stdlib/spec/acceptance/nodesets/windows-2008r2-x86_64.yml @@ -0,0 +1,26 @@ +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/ diff --git a/stdlib/spec/acceptance/nodesets/windows-2012-x86_64.yml b/stdlib/spec/acceptance/nodesets/windows-2012-x86_64.yml new file mode 100644 index 000000000..eaa4eca90 --- /dev/null +++ b/stdlib/spec/acceptance/nodesets/windows-2012-x86_64.yml @@ -0,0 +1,26 @@ +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/ diff --git a/stdlib/spec/acceptance/nodesets/windows-2012r2-x86_64.yml b/stdlib/spec/acceptance/nodesets/windows-2012r2-x86_64.yml new file mode 100644 index 000000000..1f0ea97c7 --- /dev/null +++ b/stdlib/spec/acceptance/nodesets/windows-2012r2-x86_64.yml @@ -0,0 +1,26 @@ +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/ diff --git a/stdlib/spec/acceptance/num2bool_spec.rb b/stdlib/spec/acceptance/num2bool_spec.rb new file mode 100755 index 000000000..1d99ba025 --- /dev/null +++ b/stdlib/spec/acceptance/num2bool_spec.rb @@ -0,0 +1,76 @@ +#! /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 diff --git a/stdlib/spec/acceptance/parsejson_spec.rb b/stdlib/spec/acceptance/parsejson_spec.rb new file mode 100755 index 000000000..509781027 --- /dev/null +++ b/stdlib/spec/acceptance/parsejson_spec.rb @@ -0,0 +1,34 @@ +#! /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 diff --git a/stdlib/spec/acceptance/parseyaml_spec.rb b/stdlib/spec/acceptance/parseyaml_spec.rb new file mode 100755 index 000000000..5819837cf --- /dev/null +++ b/stdlib/spec/acceptance/parseyaml_spec.rb @@ -0,0 +1,35 @@ +#! /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 diff --git a/stdlib/spec/acceptance/pick_default_spec.rb b/stdlib/spec/acceptance/pick_default_spec.rb new file mode 100755 index 000000000..a663f54e8 --- /dev/null +++ b/stdlib/spec/acceptance/pick_default_spec.rb @@ -0,0 +1,54 @@ +#! /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 diff --git a/stdlib/spec/acceptance/pick_spec.rb b/stdlib/spec/acceptance/pick_spec.rb new file mode 100755 index 000000000..46cf63f28 --- /dev/null +++ b/stdlib/spec/acceptance/pick_spec.rb @@ -0,0 +1,44 @@ +#! /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 diff --git a/stdlib/spec/acceptance/prefix_spec.rb b/stdlib/spec/acceptance/prefix_spec.rb new file mode 100755 index 000000000..de55530eb --- /dev/null +++ b/stdlib/spec/acceptance/prefix_spec.rb @@ -0,0 +1,42 @@ +#! /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 diff --git a/stdlib/spec/acceptance/range_spec.rb b/stdlib/spec/acceptance/range_spec.rb new file mode 100755 index 000000000..a3ccd3396 --- /dev/null +++ b/stdlib/spec/acceptance/range_spec.rb @@ -0,0 +1,36 @@ +#! /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 diff --git a/stdlib/spec/acceptance/reject_spec.rb b/stdlib/spec/acceptance/reject_spec.rb new file mode 100755 index 000000000..7f16a008d --- /dev/null +++ b/stdlib/spec/acceptance/reject_spec.rb @@ -0,0 +1,42 @@ +#! /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 diff --git a/stdlib/spec/acceptance/reverse_spec.rb b/stdlib/spec/acceptance/reverse_spec.rb new file mode 100755 index 000000000..c3f01567a --- /dev/null +++ b/stdlib/spec/acceptance/reverse_spec.rb @@ -0,0 +1,23 @@ +#! /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 diff --git a/stdlib/spec/acceptance/rstrip_spec.rb b/stdlib/spec/acceptance/rstrip_spec.rb new file mode 100755 index 000000000..b57a8b045 --- /dev/null +++ b/stdlib/spec/acceptance/rstrip_spec.rb @@ -0,0 +1,34 @@ +#! /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 diff --git a/stdlib/spec/acceptance/shuffle_spec.rb b/stdlib/spec/acceptance/shuffle_spec.rb new file mode 100755 index 000000000..b840d1f1b --- /dev/null +++ b/stdlib/spec/acceptance/shuffle_spec.rb @@ -0,0 +1,34 @@ +#! /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 diff --git a/stdlib/spec/acceptance/size_spec.rb b/stdlib/spec/acceptance/size_spec.rb new file mode 100755 index 000000000..a52b778bd --- /dev/null +++ b/stdlib/spec/acceptance/size_spec.rb @@ -0,0 +1,55 @@ +#! /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 diff --git a/stdlib/spec/acceptance/sort_spec.rb b/stdlib/spec/acceptance/sort_spec.rb new file mode 100755 index 000000000..c85bfabd5 --- /dev/null +++ b/stdlib/spec/acceptance/sort_spec.rb @@ -0,0 +1,34 @@ +#! /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 diff --git a/stdlib/spec/acceptance/squeeze_spec.rb b/stdlib/spec/acceptance/squeeze_spec.rb new file mode 100755 index 000000000..400a458c9 --- /dev/null +++ b/stdlib/spec/acceptance/squeeze_spec.rb @@ -0,0 +1,47 @@ +#! /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 diff --git a/stdlib/spec/acceptance/str2bool_spec.rb b/stdlib/spec/acceptance/str2bool_spec.rb new file mode 100755 index 000000000..cf549dab8 --- /dev/null +++ b/stdlib/spec/acceptance/str2bool_spec.rb @@ -0,0 +1,31 @@ +#! /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 diff --git a/stdlib/spec/acceptance/str2saltedsha512_spec.rb b/stdlib/spec/acceptance/str2saltedsha512_spec.rb new file mode 100755 index 000000000..993e63bac --- /dev/null +++ b/stdlib/spec/acceptance/str2saltedsha512_spec.rb @@ -0,0 +1,22 @@ +#! /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 diff --git a/stdlib/spec/acceptance/strftime_spec.rb b/stdlib/spec/acceptance/strftime_spec.rb new file mode 100755 index 000000000..53b7f903b --- /dev/null +++ b/stdlib/spec/acceptance/strftime_spec.rb @@ -0,0 +1,22 @@ +#! /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 diff --git a/stdlib/spec/acceptance/strip_spec.rb b/stdlib/spec/acceptance/strip_spec.rb new file mode 100755 index 000000000..906fd7abe --- /dev/null +++ b/stdlib/spec/acceptance/strip_spec.rb @@ -0,0 +1,34 @@ +#! /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 diff --git a/stdlib/spec/acceptance/suffix_spec.rb b/stdlib/spec/acceptance/suffix_spec.rb new file mode 100755 index 000000000..630f866d7 --- /dev/null +++ b/stdlib/spec/acceptance/suffix_spec.rb @@ -0,0 +1,42 @@ +#! /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 diff --git a/stdlib/spec/acceptance/swapcase_spec.rb b/stdlib/spec/acceptance/swapcase_spec.rb new file mode 100755 index 000000000..b7894fbe2 --- /dev/null +++ b/stdlib/spec/acceptance/swapcase_spec.rb @@ -0,0 +1,22 @@ +#! /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 diff --git a/stdlib/spec/acceptance/time_spec.rb b/stdlib/spec/acceptance/time_spec.rb new file mode 100755 index 000000000..cdb296070 --- /dev/null +++ b/stdlib/spec/acceptance/time_spec.rb @@ -0,0 +1,36 @@ +#! /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 diff --git a/stdlib/spec/acceptance/to_bytes_spec.rb b/stdlib/spec/acceptance/to_bytes_spec.rb new file mode 100755 index 000000000..2b4c61f48 --- /dev/null +++ b/stdlib/spec/acceptance/to_bytes_spec.rb @@ -0,0 +1,27 @@ +#! /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 diff --git a/stdlib/spec/acceptance/type_spec.rb b/stdlib/spec/acceptance/type_spec.rb new file mode 100755 index 000000000..67e324803 --- /dev/null +++ b/stdlib/spec/acceptance/type_spec.rb @@ -0,0 +1,37 @@ +#! /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 diff --git a/stdlib/spec/acceptance/union_spec.rb b/stdlib/spec/acceptance/union_spec.rb new file mode 100755 index 000000000..6db8d0cf9 --- /dev/null +++ b/stdlib/spec/acceptance/union_spec.rb @@ -0,0 +1,24 @@ +#! /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 diff --git a/stdlib/spec/acceptance/unique_spec.rb b/stdlib/spec/acceptance/unique_spec.rb new file mode 100755 index 000000000..bfadad19b --- /dev/null +++ b/stdlib/spec/acceptance/unique_spec.rb @@ -0,0 +1,33 @@ +#! /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 diff --git a/stdlib/spec/acceptance/unsupported_spec.rb b/stdlib/spec/acceptance/unsupported_spec.rb old mode 100644 new mode 100755 index 449f35a63..1c559f67e --- a/stdlib/spec/acceptance/unsupported_spec.rb +++ b/stdlib/spec/acceptance/unsupported_spec.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'spec_helper_acceptance' describe 'unsupported distributions and OSes', :if => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do diff --git a/stdlib/spec/acceptance/upcase_spec.rb b/stdlib/spec/acceptance/upcase_spec.rb new file mode 100755 index 000000000..3d2906d72 --- /dev/null +++ b/stdlib/spec/acceptance/upcase_spec.rb @@ -0,0 +1,33 @@ +#! /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 diff --git a/stdlib/spec/acceptance/uriescape_spec.rb b/stdlib/spec/acceptance/uriescape_spec.rb new file mode 100755 index 000000000..7e30205e8 --- /dev/null +++ b/stdlib/spec/acceptance/uriescape_spec.rb @@ -0,0 +1,23 @@ +#! /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 diff --git a/stdlib/spec/acceptance/validate_absolute_path_spec.rb b/stdlib/spec/acceptance/validate_absolute_path_spec.rb new file mode 100755 index 000000000..7082e848e --- /dev/null +++ b/stdlib/spec/acceptance/validate_absolute_path_spec.rb @@ -0,0 +1,31 @@ +#! /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 diff --git a/stdlib/spec/acceptance/validate_array_spec.rb b/stdlib/spec/acceptance/validate_array_spec.rb new file mode 100755 index 000000000..b53e98c27 --- /dev/null +++ b/stdlib/spec/acceptance/validate_array_spec.rb @@ -0,0 +1,37 @@ +#! /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 diff --git a/stdlib/spec/acceptance/validate_augeas_spec.rb b/stdlib/spec/acceptance/validate_augeas_spec.rb new file mode 100755 index 000000000..71a4c8425 --- /dev/null +++ b/stdlib/spec/acceptance/validate_augeas_spec.rb @@ -0,0 +1,63 @@ +#! /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 diff --git a/stdlib/spec/acceptance/validate_bool_spec.rb b/stdlib/spec/acceptance/validate_bool_spec.rb new file mode 100755 index 000000000..c837f089f --- /dev/null +++ b/stdlib/spec/acceptance/validate_bool_spec.rb @@ -0,0 +1,37 @@ +#! /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 diff --git a/stdlib/spec/acceptance/validate_cmd_spec.rb b/stdlib/spec/acceptance/validate_cmd_spec.rb new file mode 100755 index 000000000..5ac66fdbf --- /dev/null +++ b/stdlib/spec/acceptance/validate_cmd_spec.rb @@ -0,0 +1,52 @@ +#! /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 diff --git a/stdlib/spec/acceptance/validate_hash_spec.rb b/stdlib/spec/acceptance/validate_hash_spec.rb new file mode 100755 index 000000000..52fb615bd --- /dev/null +++ b/stdlib/spec/acceptance/validate_hash_spec.rb @@ -0,0 +1,37 @@ +#! /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 diff --git a/stdlib/spec/acceptance/validate_ipv4_address_spec.rb b/stdlib/spec/acceptance/validate_ipv4_address_spec.rb new file mode 100755 index 000000000..64841c371 --- /dev/null +++ b/stdlib/spec/acceptance/validate_ipv4_address_spec.rb @@ -0,0 +1,31 @@ +#! /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 diff --git a/stdlib/spec/acceptance/validate_ipv6_address_spec.rb b/stdlib/spec/acceptance/validate_ipv6_address_spec.rb new file mode 100755 index 000000000..6426d1a52 --- /dev/null +++ b/stdlib/spec/acceptance/validate_ipv6_address_spec.rb @@ -0,0 +1,31 @@ +#! /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 diff --git a/stdlib/spec/acceptance/validate_re_spec.rb b/stdlib/spec/acceptance/validate_re_spec.rb new file mode 100755 index 000000000..22f6d47d1 --- /dev/null +++ b/stdlib/spec/acceptance/validate_re_spec.rb @@ -0,0 +1,47 @@ +#! /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 diff --git a/stdlib/spec/acceptance/validate_slength_spec.rb b/stdlib/spec/acceptance/validate_slength_spec.rb new file mode 100755 index 000000000..1ab2bb986 --- /dev/null +++ b/stdlib/spec/acceptance/validate_slength_spec.rb @@ -0,0 +1,72 @@ +#! /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 diff --git a/stdlib/spec/acceptance/validate_string_spec.rb b/stdlib/spec/acceptance/validate_string_spec.rb new file mode 100755 index 000000000..8956f48c9 --- /dev/null +++ b/stdlib/spec/acceptance/validate_string_spec.rb @@ -0,0 +1,36 @@ +#! /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 diff --git a/stdlib/spec/acceptance/values_at_spec.rb b/stdlib/spec/acceptance/values_at_spec.rb new file mode 100755 index 000000000..da63cf307 --- /dev/null +++ b/stdlib/spec/acceptance/values_at_spec.rb @@ -0,0 +1,73 @@ +#! /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 diff --git a/stdlib/spec/acceptance/values_spec.rb b/stdlib/spec/acceptance/values_spec.rb new file mode 100755 index 000000000..a2eff329d --- /dev/null +++ b/stdlib/spec/acceptance/values_spec.rb @@ -0,0 +1,35 @@ +#! /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 diff --git a/stdlib/spec/acceptance/zip_spec.rb b/stdlib/spec/acceptance/zip_spec.rb new file mode 100755 index 000000000..139079e31 --- /dev/null +++ b/stdlib/spec/acceptance/zip_spec.rb @@ -0,0 +1,86 @@ +#! /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 diff --git a/stdlib/spec/classes/anchor_spec.rb b/stdlib/spec/classes/anchor_spec.rb old mode 100644 new mode 100755 index 2e1fcba46..2d4455e41 --- a/stdlib/spec/classes/anchor_spec.rb +++ b/stdlib/spec/classes/anchor_spec.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'spec_helper' require 'puppet_spec/compiler' diff --git a/stdlib/spec/unit/puppet/parser/functions/abs_spec.rb b/stdlib/spec/functions/abs_spec.rb similarity index 68% rename from stdlib/spec/unit/puppet/parser/functions/abs_spec.rb rename to stdlib/spec/functions/abs_spec.rb index c0b42970c..3c25ce28f 100755 --- a/stdlib/spec/unit/puppet/parser/functions/abs_spec.rb +++ b/stdlib/spec/functions/abs_spec.rb @@ -6,20 +6,20 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("abs").should == "function_abs" + expect(Puppet::Parser::Functions.function("abs")).to eq("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)) + 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"]) - result.should(eq(34)) + expect(result).to(eq(34)) end it "should do nothing with a positive number" do result = scope.function_abs(["5678"]) - result.should(eq(5678)) + expect(result).to(eq(5678)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/any2array_spec.rb b/stdlib/spec/functions/any2array_spec.rb old mode 100644 new mode 100755 similarity index 74% rename from stdlib/spec/unit/puppet/parser/functions/any2array_spec.rb rename to stdlib/spec/functions/any2array_spec.rb index b266e84f4..87cd04b5e --- a/stdlib/spec/unit/puppet/parser/functions/any2array_spec.rb +++ b/stdlib/spec/functions/any2array_spec.rb @@ -5,51 +5,51 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("any2array").should == "function_any2array" + 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([]) - result.should(eq([])) + expect(result).to(eq([])) end it "should convert boolean true to [ true ] " do result = scope.function_any2array([true]) - result.should(eq([true])) + expect(result).to(eq([true])) end it "should convert one object to [object]" do result = scope.function_any2array(['one']) - result.should(eq(['one'])) + expect(result).to(eq(['one'])) end it "should convert multiple objects to [objects]" do result = scope.function_any2array(['one', 'two']) - result.should(eq(['one', 'two'])) + expect(result).to(eq(['one', 'two'])) end it "should return empty array it was called with" do result = scope.function_any2array([[]]) - result.should(eq([])) + expect(result).to(eq([])) end it "should return one-member array it was called with" do result = scope.function_any2array([['string']]) - result.should(eq(['string'])) + expect(result).to(eq(['string'])) end it "should return multi-member array it was called with" do result = scope.function_any2array([['one', 'two']]) - result.should(eq(['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' }]) - result.should(eq(['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([{ }]) - result.should(eq([])) + expect(result).to(eq([])) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/base64_spec.rb b/stdlib/spec/functions/base64_spec.rb similarity index 87% rename from stdlib/spec/unit/puppet/parser/functions/base64_spec.rb rename to stdlib/spec/functions/base64_spec.rb index 5faa5e66c..e93fafcd0 100755 --- a/stdlib/spec/unit/puppet/parser/functions/base64_spec.rb +++ b/stdlib/spec/functions/base64_spec.rb @@ -6,7 +6,7 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("base64").should == "function_base64" + expect(Puppet::Parser::Functions.function("base64")).to eq("function_base64") end it "should raise a ParseError if there are other than 2 arguments" do @@ -25,10 +25,10 @@ it "should encode a encoded string" do result = scope.function_base64(["encode",'thestring']) - result.should =~ /\AdGhlc3RyaW5n\n\Z/ + expect(result).to match(/\AdGhlc3RyaW5n\n\Z/) end it "should decode a base64 encoded string" do result = scope.function_base64(["decode",'dGhlc3RyaW5n']) - result.should == 'thestring' + expect(result).to eq('thestring') end end diff --git a/stdlib/spec/functions/bool2num_spec.rb b/stdlib/spec/functions/bool2num_spec.rb new file mode 100755 index 000000000..3904d7e40 --- /dev/null +++ b/stdlib/spec/functions/bool2num_spec.rb @@ -0,0 +1,38 @@ +#! /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 diff --git a/stdlib/spec/functions/capitalize_spec.rb b/stdlib/spec/functions/capitalize_spec.rb new file mode 100755 index 000000000..fd0e92ba2 --- /dev/null +++ b/stdlib/spec/functions/capitalize_spec.rb @@ -0,0 +1,28 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/chomp_spec.rb b/stdlib/spec/functions/chomp_spec.rb similarity index 50% rename from stdlib/spec/unit/puppet/parser/functions/chomp_spec.rb rename to stdlib/spec/functions/chomp_spec.rb index e425365fc..b1e1e60f3 100755 --- a/stdlib/spec/unit/puppet/parser/functions/chomp_spec.rb +++ b/stdlib/spec/functions/chomp_spec.rb @@ -5,15 +5,24 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("chomp").should == "function_chomp" + expect(Puppet::Parser::Functions.function("chomp")).to eq("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)) + 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 diff --git a/stdlib/spec/functions/chop_spec.rb b/stdlib/spec/functions/chop_spec.rb new file mode 100755 index 000000000..c8a19519a --- /dev/null +++ b/stdlib/spec/functions/chop_spec.rb @@ -0,0 +1,28 @@ +#! /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 diff --git a/stdlib/spec/functions/concat_spec.rb b/stdlib/spec/functions/concat_spec.rb new file mode 100755 index 000000000..49fa6bb36 --- /dev/null +++ b/stdlib/spec/functions/concat_spec.rb @@ -0,0 +1,50 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/count_spec.rb b/stdlib/spec/functions/count_spec.rb old mode 100644 new mode 100755 similarity index 62% rename from stdlib/spec/unit/puppet/parser/functions/count_spec.rb rename to stdlib/spec/functions/count_spec.rb index 2453815c2..f8f1d4842 --- a/stdlib/spec/unit/puppet/parser/functions/count_spec.rb +++ b/stdlib/spec/functions/count_spec.rb @@ -6,23 +6,23 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("count").should == "function_count" + expect(Puppet::Parser::Functions.function("count")).to eq("function_count") end it "should raise a ArgumentError if there is more than 2 arguments" do - lambda { scope.function_count(['foo', 'bar', 'baz']) }.should( raise_error(ArgumentError)) + expect { scope.function_count(['foo', 'bar', 'baz']) }.to( raise_error(ArgumentError)) end it "should be able to count arrays" do - scope.function_count([["1","2","3"]]).should(eq(3)) + expect(scope.function_count([["1","2","3"]])).to(eq(3)) end it "should be able to count matching elements in arrays" do - scope.function_count([["1", "2", "2"], "2"]).should(eq(2)) + expect(scope.function_count([["1", "2", "2"], "2"])).to(eq(2)) end it "should not count nil or empty strings" do - scope.function_count([["foo","bar",nil,""]]).should(eq(2)) + 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/deep_merge_spec.rb b/stdlib/spec/functions/deep_merge_spec.rb old mode 100644 new mode 100755 similarity index 67% rename from stdlib/spec/unit/puppet/parser/functions/deep_merge_spec.rb rename to stdlib/spec/functions/deep_merge_spec.rb index f1347014c..7087904a8 --- a/stdlib/spec/unit/puppet/parser/functions/deep_merge_spec.rb +++ b/stdlib/spec/functions/deep_merge_spec.rb @@ -7,7 +7,7 @@ describe 'when calling deep_merge from puppet' do it "should not compile when no arguments are passed" do - pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ + skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ Puppet[:code] = '$x = deep_merge()' expect { scope.compiler.compile @@ -15,7 +15,7 @@ end it "should not compile when 1 argument is passed" do - pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ + 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 @@ -35,71 +35,71 @@ it 'should be able to deep_merge two hashes' do new_hash = scope.function_deep_merge([{'one' => '1', 'two' => '1'}, {'two' => '2', 'three' => '2'}]) - new_hash['one'].should == '1' - new_hash['two'].should == '2' - new_hash['three'].should == '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'}]) - hash['one'].should == '3' + expect(hash['one']).to eq('3') end it 'should accept empty hashes' do - scope.function_deep_merge([{},{},{}]).should == {} + 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 } }]) - hash['one'].should == 1 - hash['two'].should == 2 - hash['three'].should == { '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 } }]) - hash['one'].should == { 'two' => 2, '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 } }]) - hash['one'].should == 1 - hash['two'].should == 'dos' - hash['three'].should == { 'four' => 4, '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 } }]) - hash['key1'].should == { 'a' => 1, 'b' => 99 } - hash['key2'].should == { 'c' => 3 } + 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]) - hash1.should == {'one' => { 'two' => 2 } } - hash2.should == { 'one' => { 'three' => 3 } } - hash['one'].should == { 'two' => 2, 'three' => 3 } + 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]) - hash1.should == {'one' => { 'two' => [1,2] } } - hash2.should == { 'one' => { 'three' => 3 } } - hash['one'].should == { 'two' => [1,2], 'three' => 3 } + 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]) - hash1.should == {'one' => { 'two' => [1,2, {'two' => 2}] } } - hash2.should == { 'one' => { 'three' => 3 } } - hash['one'].should == { 'two' => [1,2, {'two' => 2} ], 'three' => 3 } - hash['one']['two'].should == [1,2, {'two' => 2}] + 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 diff --git a/stdlib/spec/functions/defined_with_params_spec.rb b/stdlib/spec/functions/defined_with_params_spec.rb old mode 100644 new mode 100755 index 28dbab311..359030474 --- a/stdlib/spec/functions/defined_with_params_spec.rb +++ b/stdlib/spec/functions/defined_with_params_spec.rb @@ -4,16 +4,16 @@ require 'rspec-puppet' describe 'defined_with_params' do describe 'when a resource is not specified' do - it { should run.with_params().and_raise_error(ArgumentError) } + 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 - should run.with_params('User[dan]', {}).and_return(true) - should run.with_params('User[bob]', {}).and_return(false) - should run.with_params('User[dan]', {'foo' => 'bar'}).and_return(false) + 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 @@ -22,14 +22,14 @@ 'user { "dan": ensure => present, shell => "/bin/csh", managehome => false}' end it do - should run.with_params('User[dan]', {}).and_return(true) - should run.with_params('User[dan]', '').and_return(true) - should run.with_params('User[dan]', {'ensure' => 'present'} + 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) - should run.with_params('User[dan]', + is_expected.to run.with_params('User[dan]', {'ensure' => 'present', 'managehome' => false} ).and_return(true) - should run.with_params('User[dan]', + is_expected.to run.with_params('User[dan]', {'ensure' => 'absent', 'managehome' => false} ).and_return(false) end diff --git a/stdlib/spec/unit/puppet/parser/functions/delete_at_spec.rb b/stdlib/spec/functions/delete_at_spec.rb similarity index 68% rename from stdlib/spec/unit/puppet/parser/functions/delete_at_spec.rb rename to stdlib/spec/functions/delete_at_spec.rb index 593cf4592..7c20aec42 100755 --- a/stdlib/spec/unit/puppet/parser/functions/delete_at_spec.rb +++ b/stdlib/spec/functions/delete_at_spec.rb @@ -5,21 +5,21 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("delete_at").should == "function_delete_at" + 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 - lambda { scope.function_delete_at([]) }.should( raise_error(Puppet::ParseError)) + 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]) - result.should(eq(['a','c'])) + 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]) - origin_array.should(eq(['a','b','c','d'])) + expect(origin_array).to(eq(['a','b','c','d'])) end end diff --git a/stdlib/spec/functions/delete_spec.rb b/stdlib/spec/functions/delete_spec.rb new file mode 100755 index 000000000..c8edd78e2 --- /dev/null +++ b/stdlib/spec/functions/delete_spec.rb @@ -0,0 +1,61 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/delete_undef_values_spec.rb b/stdlib/spec/functions/delete_undef_values_spec.rb old mode 100644 new mode 100755 similarity index 62% rename from stdlib/spec/unit/puppet/parser/functions/delete_undef_values_spec.rb rename to stdlib/spec/functions/delete_undef_values_spec.rb index b341d888a..dc679535f --- a/stdlib/spec/unit/puppet/parser/functions/delete_undef_values_spec.rb +++ b/stdlib/spec/functions/delete_undef_values_spec.rb @@ -5,37 +5,37 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("delete_undef_values").should == "function_delete_undef_values" + 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 - lambda { scope.function_delete_undef_values([]) }.should( raise_error(Puppet::ParseError)) + 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 - lambda { scope.function_delete_undef_values(['']) }.should( raise_error(Puppet::ParseError)) - lambda { scope.function_delete_undef_values([nil]) }.should( raise_error(Puppet::ParseError)) + 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']]) - result.should(eq(['a','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'}]) - result.should(eq({'a'=>'A','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]) - origin_array.should(eq(['a',:undef,'c','undef'])) + 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]) - origin_hash.should(eq({ 'a' => 1, 'b' => :undef, 'c' => 'undef' })) + expect(origin_hash).to(eq({ 'a' => 1, 'b' => :undef, 'c' => 'undef' })) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/delete_values_spec.rb b/stdlib/spec/functions/delete_values_spec.rb old mode 100644 new mode 100755 similarity index 55% rename from stdlib/spec/unit/puppet/parser/functions/delete_values_spec.rb rename to stdlib/spec/functions/delete_values_spec.rb index 8d7f2315d..4f4d411b8 --- a/stdlib/spec/unit/puppet/parser/functions/delete_values_spec.rb +++ b/stdlib/spec/functions/delete_values_spec.rb @@ -5,32 +5,32 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("delete_values").should == "function_delete_values" + 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 - lambda { scope.function_delete_values([]) }.should( raise_error(Puppet::ParseError)) + expect { scope.function_delete_values([]) }.to( raise_error(Puppet::ParseError)) end it "should raise a ParseError if there are greater than 2 arguments" do - lambda { scope.function_delete_values([[], 'foo', 'bar']) }.should( raise_error(Puppet::ParseError)) + 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 - lambda { scope.function_delete_values([1,'bar']) }.should( raise_error(TypeError)) - lambda { scope.function_delete_values(['foo','bar']) }.should( raise_error(TypeError)) - lambda { scope.function_delete_values([[],'bar']) }.should( raise_error(TypeError)) + 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']) - result.should(eq({ 'a'=>'A', 'B'=>'C' })) + 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]) - origin_hash.should(eq({ 'a' => 1, 'b' => 2, 'c' => 3 })) + expect(origin_hash).to(eq({ 'a' => 1, 'b' => 2, 'c' => 3 })) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/difference_spec.rb b/stdlib/spec/functions/difference_spec.rb old mode 100644 new mode 100755 similarity index 65% rename from stdlib/spec/unit/puppet/parser/functions/difference_spec.rb rename to stdlib/spec/functions/difference_spec.rb index 9feff0918..24b2b1bc6 --- a/stdlib/spec/unit/puppet/parser/functions/difference_spec.rb +++ b/stdlib/spec/functions/difference_spec.rb @@ -5,15 +5,15 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("difference").should == "function_difference" + expect(Puppet::Parser::Functions.function("difference")).to eq("function_difference") end it "should raise a ParseError if there are fewer than 2 arguments" do - lambda { scope.function_difference([]) }.should( raise_error(Puppet::ParseError) ) + 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"]]) - result.should(eq(["a"])) + expect(result).to(eq(["a"])) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/dirname_spec.rb b/stdlib/spec/functions/dirname_spec.rb similarity index 67% rename from stdlib/spec/unit/puppet/parser/functions/dirname_spec.rb rename to stdlib/spec/functions/dirname_spec.rb index fb3b4feca..8a3bcabfc 100755 --- a/stdlib/spec/unit/puppet/parser/functions/dirname_spec.rb +++ b/stdlib/spec/functions/dirname_spec.rb @@ -5,20 +5,20 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("dirname").should == "function_dirname" + expect(Puppet::Parser::Functions.function("dirname")).to eq("function_dirname") end it "should raise a ParseError if there is less than 1 arguments" do - lambda { scope.function_dirname([]) }.should( raise_error(Puppet::ParseError)) + expect { scope.function_dirname([]) }.to( raise_error(Puppet::ParseError)) end it "should return dirname for an absolute path" do result = scope.function_dirname(['/path/to/a/file.ext']) - result.should(eq('/path/to/a')) + 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']) - result.should(eq('path/to/a')) + expect(result).to(eq('path/to/a')) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/downcase_spec.rb b/stdlib/spec/functions/downcase_spec.rb similarity index 51% rename from stdlib/spec/unit/puppet/parser/functions/downcase_spec.rb rename to stdlib/spec/functions/downcase_spec.rb index acef1f05d..edebc44f1 100755 --- a/stdlib/spec/unit/puppet/parser/functions/downcase_spec.rb +++ b/stdlib/spec/functions/downcase_spec.rb @@ -5,20 +5,29 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("downcase").should == "function_downcase" + expect(Puppet::Parser::Functions.function("downcase")).to eq("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)) + expect { scope.function_downcase([]) }.to( raise_error(Puppet::ParseError)) end it "should downcase a string" do result = scope.function_downcase(["ASFD"]) - result.should(eq("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"]) - result.should(eq("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 diff --git a/stdlib/spec/unit/puppet/parser/functions/empty_spec.rb b/stdlib/spec/functions/empty_spec.rb similarity index 55% rename from stdlib/spec/unit/puppet/parser/functions/empty_spec.rb rename to stdlib/spec/functions/empty_spec.rb index 774587522..6a97c4cd3 100755 --- a/stdlib/spec/unit/puppet/parser/functions/empty_spec.rb +++ b/stdlib/spec/functions/empty_spec.rb @@ -4,20 +4,29 @@ describe "the empty function" do let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("empty").should == "function_empty" + expect(Puppet::Parser::Functions.function("empty")).to eq("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)) + expect { scope.function_empty([]) }.to( raise_error(Puppet::ParseError)) end it "should return a true for an empty string" do result = scope.function_empty(['']) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return a false for a non-empty string" do result = scope.function_empty(['asdf']) - result.should(eq(false)) + 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 diff --git a/stdlib/spec/functions/ensure_packages_spec.rb b/stdlib/spec/functions/ensure_packages_spec.rb old mode 100644 new mode 100755 index bf62eff42..436be10bc --- a/stdlib/spec/functions/ensure_packages_spec.rb +++ b/stdlib/spec/functions/ensure_packages_spec.rb @@ -32,7 +32,7 @@ it 'fails with no arguments' do expect { scope.function_ensure_packages([]) - }.to raise_error(Puppet::ParseError, /0 for 1/) + }.to raise_error(Puppet::ParseError, /0 for 1 or 2/) end it 'accepts an array of values' do @@ -67,4 +67,15 @@ 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 diff --git a/stdlib/spec/functions/ensure_resource_spec.rb b/stdlib/spec/functions/ensure_resource_spec.rb old mode 100644 new mode 100755 index 459d917b2..33bcac0d1 --- a/stdlib/spec/functions/ensure_resource_spec.rb +++ b/stdlib/spec/functions/ensure_resource_spec.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'spec_helper' require 'rspec-puppet' require 'puppet_spec/compiler' diff --git a/stdlib/spec/unit/puppet/parser/functions/flatten_spec.rb b/stdlib/spec/functions/flatten_spec.rb similarity index 62% rename from stdlib/spec/unit/puppet/parser/functions/flatten_spec.rb rename to stdlib/spec/functions/flatten_spec.rb index dba7a6bbd..de8c66d66 100755 --- a/stdlib/spec/unit/puppet/parser/functions/flatten_spec.rb +++ b/stdlib/spec/functions/flatten_spec.rb @@ -4,24 +4,24 @@ describe "the flatten function" do let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("flatten").should == "function_flatten" + expect(Puppet::Parser::Functions.function("flatten")).to eq("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)) + expect { scope.function_flatten([]) }.to( raise_error(Puppet::ParseError)) end it "should raise a ParseError if there is more than 1 argument" do - lambda { scope.function_flatten([[], []]) }.should( raise_error(Puppet::ParseError)) + 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"]]]) - result.should(eq(["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"]]) - result.should(eq(["a","b","c","d"])) + expect(result).to(eq(["a","b","c","d"])) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/floor_spec.rb b/stdlib/spec/functions/floor_spec.rb old mode 100644 new mode 100755 similarity index 60% rename from stdlib/spec/unit/puppet/parser/functions/floor_spec.rb rename to stdlib/spec/functions/floor_spec.rb index dbc8c7735..12a691798 --- a/stdlib/spec/unit/puppet/parser/functions/floor_spec.rb +++ b/stdlib/spec/functions/floor_spec.rb @@ -6,34 +6,34 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("floor").should == "function_floor" + expect(Puppet::Parser::Functions.function("floor")).to eq("function_floor") end it "should raise a ParseError if there is less than 1 argument" do - lambda { scope.function_floor([]) }.should( raise_error(Puppet::ParseError, /Wrong number of arguments/)) + 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 - lambda { scope.function_floor(["foo"]) }.should( raise_error(Puppet::ParseError, /Wrong argument type/)) + 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 - lambda { scope.function_floor([true]) }.should( raise_error(Puppet::ParseError, /Wrong argument type/)) + 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]) - result.is_a?(Integer).should(eq(true)) + 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]) - result.should(eq(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]) - result.should(eq(3)) + expect(result).to(eq(3)) end end diff --git a/stdlib/spec/functions/fqdn_rotate_spec.rb b/stdlib/spec/functions/fqdn_rotate_spec.rb new file mode 100755 index 000000000..673a8a321 --- /dev/null +++ b/stdlib/spec/functions/fqdn_rotate_spec.rb @@ -0,0 +1,60 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/get_module_path_spec.rb b/stdlib/spec/functions/get_module_path_spec.rb old mode 100644 new mode 100755 similarity index 83% rename from stdlib/spec/unit/puppet/parser/functions/get_module_path_spec.rb rename to stdlib/spec/functions/get_module_path_spec.rb index 486bef6f2..38ce64597 --- a/stdlib/spec/unit/puppet/parser/functions/get_module_path_spec.rb +++ b/stdlib/spec/functions/get_module_path_spec.rb @@ -29,18 +29,18 @@ def scope(environment = "production") 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) - scope.function_get_module_path(['foo']).should == path_of_module_foo.path + 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) - scope.function_get_module_path(['foo']).should == path_of_module_foo.path + expect(scope.function_get_module_path(['foo'])).to eq(path_of_module_foo.path) end it 'should respect the environment' do - pending("Disabled on Puppet 2.6.x") if Puppet.version =~ /^2\.6\b/ + 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) - scope('danstestenv').function_get_module_path(['foo']).should == path_of_module_foo.path + expect(scope('danstestenv').function_get_module_path(['foo'])).to eq(path_of_module_foo.path) end end end diff --git a/stdlib/spec/functions/getparam_spec.rb b/stdlib/spec/functions/getparam_spec.rb old mode 100644 new mode 100755 index 7f5ad1a1e..833c4d4fb --- a/stdlib/spec/functions/getparam_spec.rb +++ b/stdlib/spec/functions/getparam_spec.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'spec_helper' require 'rspec-puppet' require 'puppet_spec/compiler' @@ -24,7 +25,7 @@ end it "should exist" do - Puppet::Parser::Functions.function("getparam").should == "function_getparam" + expect(Puppet::Parser::Functions.function("getparam")).to eq("function_getparam") end describe 'when a resource is not specified' do diff --git a/stdlib/spec/unit/puppet/parser/functions/getvar_spec.rb b/stdlib/spec/functions/getvar_spec.rb old mode 100644 new mode 100755 similarity index 81% rename from stdlib/spec/unit/puppet/parser/functions/getvar_spec.rb rename to stdlib/spec/functions/getvar_spec.rb index 5ff834ee7..87ab9b5ac --- a/stdlib/spec/unit/puppet/parser/functions/getvar_spec.rb +++ b/stdlib/spec/functions/getvar_spec.rb @@ -6,7 +6,7 @@ describe 'when calling getvar from puppet' do it "should not compile when no arguments are passed" do - pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ + skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ Puppet[:code] = '$foo = getvar()' expect { scope.compiler.compile @@ -14,7 +14,7 @@ end it "should not compile when too many arguments are passed" do - pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ + 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 @@ -22,7 +22,7 @@ end it "should lookup variables in other namespaces" do - pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ + 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/grep_spec.rb b/stdlib/spec/functions/grep_spec.rb similarity index 65% rename from stdlib/spec/unit/puppet/parser/functions/grep_spec.rb rename to stdlib/spec/functions/grep_spec.rb index a93b84253..9c671dd86 100755 --- a/stdlib/spec/unit/puppet/parser/functions/grep_spec.rb +++ b/stdlib/spec/functions/grep_spec.rb @@ -5,15 +5,15 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("grep").should == "function_grep" + expect(Puppet::Parser::Functions.function("grep")).to eq("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)) + 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"]) - result.should(eq(["aaabbb","bbbccc"])) + expect(result).to(eq(["aaabbb","bbbccc"])) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/has_interface_with_spec.rb b/stdlib/spec/functions/has_interface_with_spec.rb similarity index 74% rename from stdlib/spec/unit/puppet/parser/functions/has_interface_with_spec.rb rename to stdlib/spec/functions/has_interface_with_spec.rb index c5264e4f3..23e09a955 100755 --- a/stdlib/spec/unit/puppet/parser/functions/has_interface_with_spec.rb +++ b/stdlib/spec/functions/has_interface_with_spec.rb @@ -20,10 +20,10 @@ scope.stubs(:lookupvar).with("interfaces").returns('lo0,gif0,stf0,en1,p2p0,fw0,en0,vmnet1,vmnet8,utun0') end it 'should have loopback (lo0)' do - subject.call(['lo0']).should be_true + expect(subject.call(['lo0'])).to be_truthy end it 'should not have loopback (lo)' do - subject.call(['lo']).should be_false + expect(subject.call(['lo'])).to be_falsey end end context "On Linux Systems" do @@ -37,28 +37,28 @@ scope.stubs(:lookupvar).with('muppet_eth0').returns('kermit') end it 'should have loopback (lo)' do - subject.call(['lo']).should be_true + expect(subject.call(['lo'])).to be_truthy end it 'should not have loopback (lo0)' do - subject.call(['lo0']).should be_false + expect(subject.call(['lo0'])).to be_falsey end it 'should have ipaddress with 127.0.0.1' do - subject.call(['ipaddress', '127.0.0.1']).should be_true + expect(subject.call(['ipaddress', '127.0.0.1'])).to be_truthy end it 'should have ipaddress with 10.0.0.1' do - subject.call(['ipaddress', '10.0.0.1']).should be_true + expect(subject.call(['ipaddress', '10.0.0.1'])).to be_truthy end it 'should not have ipaddress with 10.0.0.2' do - subject.call(['ipaddress', '10.0.0.2']).should be_false + expect(subject.call(['ipaddress', '10.0.0.2'])).to be_falsey end it 'should have muppet named kermit' do - subject.call(['muppet', 'kermit']).should be_true + expect(subject.call(['muppet', 'kermit'])).to be_truthy end it 'should have muppet named mspiggy' do - subject.call(['muppet', 'mspiggy']).should be_true + expect(subject.call(['muppet', 'mspiggy'])).to be_truthy end it 'should not have muppet named bigbird' do - subject.call(['muppet', 'bigbird']).should be_false + expect(subject.call(['muppet', 'bigbird'])).to be_falsey end end end diff --git a/stdlib/spec/unit/puppet/parser/functions/has_ip_address_spec.rb b/stdlib/spec/functions/has_ip_address_spec.rb similarity index 80% rename from stdlib/spec/unit/puppet/parser/functions/has_ip_address_spec.rb rename to stdlib/spec/functions/has_ip_address_spec.rb index 5a6846082..0df12a7be 100755 --- a/stdlib/spec/unit/puppet/parser/functions/has_ip_address_spec.rb +++ b/stdlib/spec/functions/has_ip_address_spec.rb @@ -21,19 +21,19 @@ end it 'should have primary address (10.0.2.15)' do - subject.call(['10.0.2.15']).should be_true + expect(subject.call(['10.0.2.15'])).to be_truthy end it 'should have lookupback address (127.0.0.1)' do - subject.call(['127.0.0.1']).should be_true + expect(subject.call(['127.0.0.1'])).to be_truthy end it 'should not have other address' do - subject.call(['192.1681.1.1']).should be_false + expect(subject.call(['192.1681.1.1'])).to be_falsey end it 'should not have "mspiggy" on an interface' do - subject.call(['mspiggy']).should be_false + expect(subject.call(['mspiggy'])).to be_falsey end end end diff --git a/stdlib/spec/unit/puppet/parser/functions/has_ip_network_spec.rb b/stdlib/spec/functions/has_ip_network_spec.rb similarity index 83% rename from stdlib/spec/unit/puppet/parser/functions/has_ip_network_spec.rb rename to stdlib/spec/functions/has_ip_network_spec.rb index c3a289e37..2a2578e23 100755 --- a/stdlib/spec/unit/puppet/parser/functions/has_ip_network_spec.rb +++ b/stdlib/spec/functions/has_ip_network_spec.rb @@ -21,15 +21,15 @@ end it 'should have primary network (10.0.2.0)' do - subject.call(['10.0.2.0']).should be_true + expect(subject.call(['10.0.2.0'])).to be_truthy end it 'should have loopback network (127.0.0.0)' do - subject.call(['127.0.0.1']).should be_true + expect(subject.call(['127.0.0.1'])).to be_truthy end it 'should not have other network' do - subject.call(['192.168.1.0']).should be_false + expect(subject.call(['192.168.1.0'])).to be_falsey end end end diff --git a/stdlib/spec/unit/puppet/parser/functions/has_key_spec.rb b/stdlib/spec/functions/has_key_spec.rb old mode 100644 new mode 100755 similarity index 74% rename from stdlib/spec/unit/puppet/parser/functions/has_key_spec.rb rename to stdlib/spec/functions/has_key_spec.rb index 490daeae7..6b718005a --- a/stdlib/spec/unit/puppet/parser/functions/has_key_spec.rb +++ b/stdlib/spec/functions/has_key_spec.rb @@ -6,7 +6,7 @@ describe 'when calling has_key from puppet' do it "should not compile when no arguments are passed" do - pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ + skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ Puppet[:code] = '$x = has_key()' expect { scope.compiler.compile @@ -14,7 +14,7 @@ end it "should not compile when 1 argument is passed" do - pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ + skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ Puppet[:code] = "$x = has_key('foo')" expect { scope.compiler.compile @@ -22,7 +22,7 @@ end it "should require the first value to be a Hash" do - pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ + 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 @@ -32,11 +32,11 @@ 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 + expect(scope.function_has_key([{'one' => 1}, 'one'])).to be_truthy end it 'should detect existing keys' do - scope.function_has_key([{'one' => 1}, 'two']).should be_false + expect(scope.function_has_key([{'one' => 1}, 'two'])).to be_falsey end end end diff --git a/stdlib/spec/unit/puppet/parser/functions/hash_spec.rb b/stdlib/spec/functions/hash_spec.rb old mode 100644 new mode 100755 similarity index 63% rename from stdlib/spec/unit/puppet/parser/functions/hash_spec.rb rename to stdlib/spec/functions/hash_spec.rb index 7c91be907..ec2988b02 --- a/stdlib/spec/unit/puppet/parser/functions/hash_spec.rb +++ b/stdlib/spec/functions/hash_spec.rb @@ -5,15 +5,15 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("hash").should == "function_hash" + expect(Puppet::Parser::Functions.function("hash")).to eq("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)) + 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]]) - result.should(eq({'a'=>1,'b'=>2,'c'=>3})) + expect(result).to(eq({'a'=>1,'b'=>2,'c'=>3})) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/intersection_spec.rb b/stdlib/spec/functions/intersection_spec.rb old mode 100644 new mode 100755 similarity index 64% rename from stdlib/spec/unit/puppet/parser/functions/intersection_spec.rb rename to stdlib/spec/functions/intersection_spec.rb index fd44f7fe3..6361304fe --- a/stdlib/spec/unit/puppet/parser/functions/intersection_spec.rb +++ b/stdlib/spec/functions/intersection_spec.rb @@ -5,15 +5,15 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("intersection").should == "function_intersection" + expect(Puppet::Parser::Functions.function("intersection")).to eq("function_intersection") end it "should raise a ParseError if there are fewer than 2 arguments" do - lambda { scope.function_intersection([]) }.should( raise_error(Puppet::ParseError) ) + 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"]]) - result.should(eq(["b","c"])) + expect(result).to(eq(["b","c"])) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/is_array_spec.rb b/stdlib/spec/functions/is_array_spec.rb old mode 100644 new mode 100755 similarity index 68% rename from stdlib/spec/unit/puppet/parser/functions/is_array_spec.rb rename to stdlib/spec/functions/is_array_spec.rb index e7f4bcd6d..94920a4cb --- a/stdlib/spec/unit/puppet/parser/functions/is_array_spec.rb +++ b/stdlib/spec/functions/is_array_spec.rb @@ -5,25 +5,25 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("is_array").should == "function_is_array" + 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 - lambda { scope.function_is_array([]) }.should( raise_error(Puppet::ParseError)) + 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]]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return false if passed a hash" do result = scope.function_is_array([{'a'=>1}]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if passed a string" do result = scope.function_is_array(["asdf"]) - result.should(eq(false)) + expect(result).to(eq(false)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/is_bool_spec.rb b/stdlib/spec/functions/is_bool_spec.rb old mode 100644 new mode 100755 similarity index 71% rename from stdlib/spec/unit/puppet/parser/functions/is_bool_spec.rb rename to stdlib/spec/functions/is_bool_spec.rb index c94e83a9d..4a342ba4f --- a/stdlib/spec/unit/puppet/parser/functions/is_bool_spec.rb +++ b/stdlib/spec/functions/is_bool_spec.rb @@ -5,40 +5,40 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("is_bool").should == "function_is_bool" + 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 - lambda { scope.function_is_bool([]) }.should( raise_error(Puppet::ParseError)) + 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]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return true if passed a FalseClass" do result = scope.function_is_bool([false]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return false if passed the string 'true'" do result = scope.function_is_bool(['true']) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if passed the string 'false'" do result = scope.function_is_bool(['false']) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if passed an array" do result = scope.function_is_bool([["a","b"]]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if passed a hash" do result = scope.function_is_bool([{"a" => "b"}]) - result.should(eq(false)) + expect(result).to(eq(false)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/is_domain_name_spec.rb b/stdlib/spec/functions/is_domain_name_spec.rb old mode 100644 new mode 100755 similarity index 74% rename from stdlib/spec/unit/puppet/parser/functions/is_domain_name_spec.rb rename to stdlib/spec/functions/is_domain_name_spec.rb index f2ea76dac..4d05f5cdc --- a/stdlib/spec/unit/puppet/parser/functions/is_domain_name_spec.rb +++ b/stdlib/spec/functions/is_domain_name_spec.rb @@ -5,60 +5,60 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("is_domain_name").should == "function_is_domain_name" + 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 - lambda { scope.function_is_domain_name([]) }.should( raise_error(Puppet::ParseError)) + 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"]) - result.should(be_true) + expect(result).to(be_truthy) end it "should return true if the domain is ." do result = scope.function_is_domain_name(["."]) - result.should(be_true) + 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."]) - result.should(be_true) + 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"]) - result.should(be_true) + 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"]) - result.should(be_true) + 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."]) - result.should(be_true) + expect(result).to(be_truthy) end it "should allow a single part domain" do result = scope.function_is_domain_name(["orange"]) - result.should(be_true) + 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"]) - result.should(be_false) + 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"]) - result.should(be_true) + expect(result).to(be_truthy) end it "should return false if domain name contains spaces" do result = scope.function_is_domain_name(["not valid"]) - result.should(be_false) + expect(result).to(be_falsey) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/is_float_spec.rb b/stdlib/spec/functions/is_float_spec.rb old mode 100644 new mode 100755 similarity index 69% rename from stdlib/spec/unit/puppet/parser/functions/is_float_spec.rb rename to stdlib/spec/functions/is_float_spec.rb index b7d73b04a..d926634e8 --- a/stdlib/spec/unit/puppet/parser/functions/is_float_spec.rb +++ b/stdlib/spec/functions/is_float_spec.rb @@ -5,29 +5,29 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("is_float").should == "function_is_float" + 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 - lambda { scope.function_is_float([]) }.should( raise_error(Puppet::ParseError)) + 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"]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return false if a string" do result = scope.function_is_float(["asdf"]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if an integer" do result = scope.function_is_float(["3"]) - result.should(eq(false)) + 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]) - result.should(eq(true)) + expect(result).to(eq(true)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/is_function_available.rb b/stdlib/spec/functions/is_function_available.rb old mode 100644 new mode 100755 similarity index 70% rename from stdlib/spec/unit/puppet/parser/functions/is_function_available.rb rename to stdlib/spec/functions/is_function_available.rb index d5669a758..3a9aa1b23 --- a/stdlib/spec/unit/puppet/parser/functions/is_function_available.rb +++ b/stdlib/spec/functions/is_function_available.rb @@ -11,21 +11,21 @@ end it "should exist" do - Puppet::Parser::Functions.function("is_function_available").should == "function_is_function_available" + 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 - lambda { @scope.function_is_function_available([]) }.should( raise_error(Puppet::ParseError)) + 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']) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return true if an available function is passed" do result = @scope.function_is_function_available(['require']) - result.should(eq(true)) + expect(result).to(eq(true)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/is_hash_spec.rb b/stdlib/spec/functions/is_hash_spec.rb old mode 100644 new mode 100755 similarity index 68% rename from stdlib/spec/unit/puppet/parser/functions/is_hash_spec.rb rename to stdlib/spec/functions/is_hash_spec.rb index bbebf39f9..a84941111 --- a/stdlib/spec/unit/puppet/parser/functions/is_hash_spec.rb +++ b/stdlib/spec/functions/is_hash_spec.rb @@ -5,25 +5,25 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("is_hash").should == "function_is_hash" + 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 - lambda { scope.function_is_hash([]) }.should( raise_error(Puppet::ParseError)) + 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}]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return false if passed an array" do result = scope.function_is_hash([["a","b"]]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if passed a string" do result = scope.function_is_hash(["asdf"]) - result.should(eq(false)) + expect(result).to(eq(false)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/is_integer_spec.rb b/stdlib/spec/functions/is_integer_spec.rb old mode 100644 new mode 100755 similarity index 73% rename from stdlib/spec/unit/puppet/parser/functions/is_integer_spec.rb rename to stdlib/spec/functions/is_integer_spec.rb index 24141cc7b..f0cbca807 --- a/stdlib/spec/unit/puppet/parser/functions/is_integer_spec.rb +++ b/stdlib/spec/functions/is_integer_spec.rb @@ -5,65 +5,65 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("is_integer").should == "function_is_integer" + 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 - lambda { scope.function_is_integer([]) }.should( raise_error(Puppet::ParseError)) + 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"]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return true if a negative integer" do result = scope.function_is_integer(["-7"]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return false if a float" do result = scope.function_is_integer(["3.2"]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if a string" do result = scope.function_is_integer(["asdf"]) - result.should(eq(false)) + 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]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return false if an array" do result = scope.function_is_numeric([["asdf"]]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if a hash" do result = scope.function_is_numeric([{"asdf" => false}]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if a boolean" do result = scope.function_is_numeric([true]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if a whitespace is in the string" do result = scope.function_is_numeric([" -1324"]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if it is zero prefixed" do result = scope.function_is_numeric(["0001234"]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if it is wrapped inside an array" do result = scope.function_is_numeric([[1234]]) - result.should(eq(false)) + expect(result).to(eq(false)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/is_ip_address_spec.rb b/stdlib/spec/functions/is_ip_address_spec.rb old mode 100644 new mode 100755 similarity index 71% rename from stdlib/spec/unit/puppet/parser/functions/is_ip_address_spec.rb rename to stdlib/spec/functions/is_ip_address_spec.rb index c0debb3d4..c16d12b16 --- a/stdlib/spec/unit/puppet/parser/functions/is_ip_address_spec.rb +++ b/stdlib/spec/functions/is_ip_address_spec.rb @@ -5,35 +5,35 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("is_ip_address").should == "function_is_ip_address" + 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 - lambda { scope.function_is_ip_address([]) }.should( raise_error(Puppet::ParseError)) + 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"]) - result.should(eq(true)) + 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"]) - result.should(eq(true)) + expect(result).to(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)) + expect(result).to(eq(true)) end it "should return false if not valid" do result = scope.function_is_ip_address(["asdf"]) - result.should(eq(false)) + 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"]) - result.should(eq(false)) + expect(result).to(eq(false)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/is_mac_address_spec.rb b/stdlib/spec/functions/is_mac_address_spec.rb old mode 100644 new mode 100755 similarity index 68% rename from stdlib/spec/unit/puppet/parser/functions/is_mac_address_spec.rb rename to stdlib/spec/functions/is_mac_address_spec.rb index ca9c59047..66edd197e --- a/stdlib/spec/unit/puppet/parser/functions/is_mac_address_spec.rb +++ b/stdlib/spec/functions/is_mac_address_spec.rb @@ -5,25 +5,25 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("is_mac_address").should == "function_is_mac_address" + 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 - lambda { scope.function_is_mac_address([]) }.should( raise_error(Puppet::ParseError)) + 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"]) - result.should(eq(true)) + 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"]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if not valid" do result = scope.function_is_mac_address(["not valid"]) - result.should(eq(false)) + expect(result).to(eq(false)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/is_numeric_spec.rb b/stdlib/spec/functions/is_numeric_spec.rb old mode 100644 new mode 100755 similarity index 84% rename from stdlib/spec/unit/puppet/parser/functions/is_numeric_spec.rb rename to stdlib/spec/functions/is_numeric_spec.rb index 1df149787..4176961d7 --- a/stdlib/spec/unit/puppet/parser/functions/is_numeric_spec.rb +++ b/stdlib/spec/functions/is_numeric_spec.rb @@ -5,71 +5,71 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("is_numeric").should == "function_is_numeric" + 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 - lambda { scope.function_is_numeric([]) }.should( raise_error(Puppet::ParseError)) + 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"]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return true if a float" do result = scope.function_is_numeric(["3.2"]) - result.should(eq(true)) + 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]) - result.should(eq(true)) + 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]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return false if a string" do result = scope.function_is_numeric(["asdf"]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if an array" do result = scope.function_is_numeric([["asdf"]]) - result.should(eq(false)) + 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]]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if a hash" do result = scope.function_is_numeric([{"asdf" => false}]) - result.should(eq(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}]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if a boolean" do result = scope.function_is_numeric([true]) - result.should(eq(false)) + 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"]) - result.should(eq(true)) + 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"]) - result.should(eq(false)) + expect(result).to(eq(false)) end # it "should return true if a hexadecimal" do diff --git a/stdlib/spec/unit/puppet/parser/functions/is_string_spec.rb b/stdlib/spec/functions/is_string_spec.rb old mode 100644 new mode 100755 similarity index 68% rename from stdlib/spec/unit/puppet/parser/functions/is_string_spec.rb rename to stdlib/spec/functions/is_string_spec.rb index 3756bea8b..6a0801ae8 --- a/stdlib/spec/unit/puppet/parser/functions/is_string_spec.rb +++ b/stdlib/spec/functions/is_string_spec.rb @@ -5,30 +5,30 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("is_string").should == "function_is_string" + 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 - lambda { scope.function_is_string([]) }.should( raise_error(Puppet::ParseError)) + 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"]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should return false if an integer" do result = scope.function_is_string(["3"]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if a float" do result = scope.function_is_string(["3.23"]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return false if an array" do result = scope.function_is_string([["a","b","c"]]) - result.should(eq(false)) + expect(result).to(eq(false)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/join_keys_to_values_spec.rb b/stdlib/spec/functions/join_keys_to_values_spec.rb old mode 100644 new mode 100755 similarity index 56% rename from stdlib/spec/unit/puppet/parser/functions/join_keys_to_values_spec.rb rename to stdlib/spec/functions/join_keys_to_values_spec.rb index a52fb719f..4a9ae87a2 --- a/stdlib/spec/unit/puppet/parser/functions/join_keys_to_values_spec.rb +++ b/stdlib/spec/functions/join_keys_to_values_spec.rb @@ -5,36 +5,36 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("join_keys_to_values").should == "function_join_keys_to_values" + 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 - lambda { scope.function_join_keys_to_values([{}]) }.should raise_error Puppet::ParseError + 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 - lambda { scope.function_join_keys_to_values([{}, 'foo', 'bar']) }.should raise_error Puppet::ParseError + 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 - lambda { scope.function_join_keys_to_values([[1,2], ',']) }.should raise_error TypeError + 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 - lambda { scope.function_join_keys_to_values([{}, [1,2]]) }.should raise_error TypeError + 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 - lambda { scope.function_join_keys_to_values([{}, 1]) }.should raise_error TypeError + 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([{}, ":"]) - result.should == [] + 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}, ":"]) - result.should =~ ['a:1','2:foo','b:'] + expect(result).to match_array(['a:1','2:foo','b:']) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/join_spec.rb b/stdlib/spec/functions/join_spec.rb old mode 100644 new mode 100755 similarity index 65% rename from stdlib/spec/unit/puppet/parser/functions/join_spec.rb rename to stdlib/spec/functions/join_spec.rb index aafa1a7f7..793c36fa3 --- a/stdlib/spec/unit/puppet/parser/functions/join_spec.rb +++ b/stdlib/spec/functions/join_spec.rb @@ -5,15 +5,15 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("join").should == "function_join" + expect(Puppet::Parser::Functions.function("join")).to eq("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)) + 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"], ":"]) - result.should(eq("a:b:c")) + expect(result).to(eq("a:b:c")) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/keys_spec.rb b/stdlib/spec/functions/keys_spec.rb old mode 100644 new mode 100755 similarity index 70% rename from stdlib/spec/unit/puppet/parser/functions/keys_spec.rb rename to stdlib/spec/functions/keys_spec.rb index fdd7a7073..f2e7d428e --- a/stdlib/spec/unit/puppet/parser/functions/keys_spec.rb +++ b/stdlib/spec/functions/keys_spec.rb @@ -5,17 +5,17 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("keys").should == "function_keys" + expect(Puppet::Parser::Functions.function("keys")).to eq("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)) + 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 - result.should =~ ['a','b'] + expect(result).to match_array(['a','b']) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/loadyaml_spec.rb b/stdlib/spec/functions/loadyaml_spec.rb old mode 100644 new mode 100755 similarity index 79% rename from stdlib/spec/unit/puppet/parser/functions/loadyaml_spec.rb rename to stdlib/spec/functions/loadyaml_spec.rb index fe1631826..cdc3d6f51 --- a/stdlib/spec/unit/puppet/parser/functions/loadyaml_spec.rb +++ b/stdlib/spec/functions/loadyaml_spec.rb @@ -7,7 +7,7 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("loadyaml").should == "function_loadyaml" + expect(Puppet::Parser::Functions.function("loadyaml")).to eq("function_loadyaml") end it "should raise a ParseError if there is less than 1 arguments" do @@ -20,6 +20,6 @@ fh.write("---\n aaa: 1\n bbb: 2\n ccc: 3\n ddd: 4\n") end result = scope.function_loadyaml([yaml_file]) - result.should == {"aaa" => 1, "bbb" => 2, "ccc" => 3, "ddd" => 4 } + expect(result).to eq({"aaa" => 1, "bbb" => 2, "ccc" => 3, "ddd" => 4 }) end end diff --git a/stdlib/spec/functions/lstrip_spec.rb b/stdlib/spec/functions/lstrip_spec.rb new file mode 100755 index 000000000..68cca1c5d --- /dev/null +++ b/stdlib/spec/functions/lstrip_spec.rb @@ -0,0 +1,28 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/max_spec.rb b/stdlib/spec/functions/max_spec.rb similarity index 56% rename from stdlib/spec/unit/puppet/parser/functions/max_spec.rb rename to stdlib/spec/functions/max_spec.rb index ff6f2b361..c3d8a132f 100755 --- a/stdlib/spec/unit/puppet/parser/functions/max_spec.rb +++ b/stdlib/spec/functions/max_spec.rb @@ -6,22 +6,22 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("max").should == "function_max" + expect(Puppet::Parser::Functions.function("max")).to eq("function_max") end it "should raise a ParseError if there is less than 1 arguments" do - lambda { scope.function_max([]) }.should( raise_error(Puppet::ParseError)) + expect { scope.function_max([]) }.to( raise_error(Puppet::ParseError)) end it "should be able to compare strings" do - scope.function_max(["albatross","dog","horse"]).should(eq("horse")) + expect(scope.function_max(["albatross","dog","horse"])).to(eq("horse")) end it "should be able to compare numbers" do - scope.function_max([6,8,4]).should(eq(8)) + expect(scope.function_max([6,8,4])).to(eq(8)) end it "should be able to compare a number with a stringified number" do - scope.function_max([1,"2"]).should(eq("2")) + expect(scope.function_max([1,"2"])).to(eq("2")) end end diff --git a/stdlib/spec/functions/member_spec.rb b/stdlib/spec/functions/member_spec.rb new file mode 100755 index 000000000..1a1d7c660 --- /dev/null +++ b/stdlib/spec/functions/member_spec.rb @@ -0,0 +1,34 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/merge_spec.rb b/stdlib/spec/functions/merge_spec.rb old mode 100644 new mode 100755 similarity index 80% rename from stdlib/spec/unit/puppet/parser/functions/merge_spec.rb rename to stdlib/spec/functions/merge_spec.rb index 15a5d94cf..2abf97622 --- a/stdlib/spec/unit/puppet/parser/functions/merge_spec.rb +++ b/stdlib/spec/functions/merge_spec.rb @@ -7,7 +7,7 @@ describe 'when calling merge from puppet' do it "should not compile when no arguments are passed" do - pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ + skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ Puppet[:code] = '$x = merge()' expect { scope.compiler.compile @@ -15,7 +15,7 @@ end it "should not compile when 1 argument is passed" do - pending("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./ + 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 @@ -35,18 +35,18 @@ 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' + 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'}]) - hash['one'].should == '3' + expect(hash['one']).to eq('3') end it 'should accept empty hashes' do - scope.function_merge([{},{},{}]).should == {} + expect(scope.function_merge([{},{},{}])).to eq({}) end end end diff --git a/stdlib/spec/unit/puppet/parser/functions/min_spec.rb b/stdlib/spec/functions/min_spec.rb similarity index 56% rename from stdlib/spec/unit/puppet/parser/functions/min_spec.rb rename to stdlib/spec/functions/min_spec.rb index 71d593ef0..35a08900b 100755 --- a/stdlib/spec/unit/puppet/parser/functions/min_spec.rb +++ b/stdlib/spec/functions/min_spec.rb @@ -6,22 +6,22 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("min").should == "function_min" + expect(Puppet::Parser::Functions.function("min")).to eq("function_min") end it "should raise a ParseError if there is less than 1 arguments" do - lambda { scope.function_min([]) }.should( raise_error(Puppet::ParseError)) + expect { scope.function_min([]) }.to( raise_error(Puppet::ParseError)) end it "should be able to compare strings" do - scope.function_min(["albatross","dog","horse"]).should(eq("albatross")) + expect(scope.function_min(["albatross","dog","horse"])).to(eq("albatross")) end it "should be able to compare numbers" do - scope.function_min([6,8,4]).should(eq(4)) + expect(scope.function_min([6,8,4])).to(eq(4)) end it "should be able to compare a number with a stringified number" do - scope.function_min([1,"2"]).should(eq(1)) + expect(scope.function_min([1,"2"])).to(eq(1)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/num2bool_spec.rb b/stdlib/spec/functions/num2bool_spec.rb old mode 100644 new mode 100755 similarity index 68% rename from stdlib/spec/unit/puppet/parser/functions/num2bool_spec.rb rename to stdlib/spec/functions/num2bool_spec.rb index b56196d3c..d0ba93548 --- a/stdlib/spec/unit/puppet/parser/functions/num2bool_spec.rb +++ b/stdlib/spec/functions/num2bool_spec.rb @@ -5,63 +5,63 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("num2bool").should == "function_num2bool" + expect(Puppet::Parser::Functions.function("num2bool")).to eq("function_num2bool") end it "should raise a ParseError if there are no arguments" do - lambda { scope.function_num2bool([]) }.should( raise_error(Puppet::ParseError)) + expect { scope.function_num2bool([]) }.to( raise_error(Puppet::ParseError)) end it "should raise a ParseError if there are more than 1 arguments" do - lambda { scope.function_num2bool(["foo","bar"]) }.should( raise_error(Puppet::ParseError)) + expect { scope.function_num2bool(["foo","bar"]) }.to( raise_error(Puppet::ParseError)) end it "should raise a ParseError if passed something non-numeric" do - lambda { scope.function_num2bool(["xyzzy"]) }.should( raise_error(Puppet::ParseError)) + 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"]) - result.should(be_true) + expect(result).to(be_truthy) end it "should return true if passed string 1.5" do result = scope.function_num2bool(["1.5"]) - result.should(be_true) + expect(result).to(be_truthy) end it "should return true if passed number 1" do result = scope.function_num2bool([1]) - result.should(be_true) + expect(result).to(be_truthy) end it "should return false if passed string 0" do result = scope.function_num2bool(["0"]) - result.should(be_false) + expect(result).to(be_falsey) end it "should return false if passed number 0" do result = scope.function_num2bool([0]) - result.should(be_false) + expect(result).to(be_falsey) end it "should return false if passed string -1" do result = scope.function_num2bool(["-1"]) - result.should(be_false) + expect(result).to(be_falsey) end it "should return false if passed string -1.5" do result = scope.function_num2bool(["-1.5"]) - result.should(be_false) + expect(result).to(be_falsey) end it "should return false if passed number -1" do result = scope.function_num2bool([-1]) - result.should(be_false) + expect(result).to(be_falsey) end it "should return false if passed float -1.5" do result = scope.function_num2bool([-1.5]) - result.should(be_false) + expect(result).to(be_falsey) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/parsejson_spec.rb b/stdlib/spec/functions/parsejson_spec.rb old mode 100644 new mode 100755 similarity index 65% rename from stdlib/spec/unit/puppet/parser/functions/parsejson_spec.rb rename to stdlib/spec/functions/parsejson_spec.rb index f179ac111..1dd41b960 --- a/stdlib/spec/unit/puppet/parser/functions/parsejson_spec.rb +++ b/stdlib/spec/functions/parsejson_spec.rb @@ -5,11 +5,11 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("parsejson").should == "function_parsejson" + expect(Puppet::Parser::Functions.function("parsejson")).to eq("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)) + expect { scope.function_parsejson([]) }.to( raise_error(Puppet::ParseError)) end it "should convert JSON to a data structure" do @@ -17,6 +17,6 @@ ["aaa","bbb","ccc"] EOS result = scope.function_parsejson([json]) - result.should(eq(['aaa','bbb','ccc'])) + expect(result).to(eq(['aaa','bbb','ccc'])) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/parseyaml_spec.rb b/stdlib/spec/functions/parseyaml_spec.rb old mode 100644 new mode 100755 similarity index 64% rename from stdlib/spec/unit/puppet/parser/functions/parseyaml_spec.rb rename to stdlib/spec/functions/parseyaml_spec.rb index 0c7aea8a5..e5f145ba1 --- a/stdlib/spec/unit/puppet/parser/functions/parseyaml_spec.rb +++ b/stdlib/spec/functions/parseyaml_spec.rb @@ -5,11 +5,11 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("parseyaml").should == "function_parseyaml" + expect(Puppet::Parser::Functions.function("parseyaml")).to eq("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)) + expect { scope.function_parseyaml([]) }.to( raise_error(Puppet::ParseError)) end it "should convert YAML to a data structure" do @@ -19,6 +19,6 @@ - ccc EOS result = scope.function_parseyaml([yaml]) - result.should(eq(['aaa','bbb','ccc'])) + expect(result).to(eq(['aaa','bbb','ccc'])) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/pick_default_spec.rb b/stdlib/spec/functions/pick_default_spec.rb old mode 100644 new mode 100755 similarity index 54% rename from stdlib/spec/unit/puppet/parser/functions/pick_default_spec.rb rename to stdlib/spec/functions/pick_default_spec.rb index c9235b534..db10cc354 --- a/stdlib/spec/unit/puppet/parser/functions/pick_default_spec.rb +++ b/stdlib/spec/functions/pick_default_spec.rb @@ -5,51 +5,51 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("pick_default").should == "function_pick_default" + expect(Puppet::Parser::Functions.function("pick_default")).to eq("function_pick_default") end it 'should return the correct value' do - scope.function_pick_default(['first', 'second']).should == 'first' + expect(scope.function_pick_default(['first', 'second'])).to eq('first') end it 'should return the correct value if the first value is empty' do - scope.function_pick_default(['', 'second']).should == 'second' + expect(scope.function_pick_default(['', 'second'])).to eq('second') end it 'should skip empty string values' do - scope.function_pick_default(['', 'first']).should == 'first' + expect(scope.function_pick_default(['', 'first'])).to eq('first') end it 'should skip :undef values' do - scope.function_pick_default([:undef, 'first']).should == 'first' + expect(scope.function_pick_default([:undef, 'first'])).to eq('first') end it 'should skip :undefined values' do - scope.function_pick_default([:undefined, 'first']).should == 'first' + expect(scope.function_pick_default([:undefined, 'first'])).to eq('first') end it 'should return the empty string if it is the last possibility' do - scope.function_pick_default([:undef, :undefined, '']).should == '' + expect(scope.function_pick_default([:undef, :undefined, ''])).to eq('') end it 'should return :undef if it is the last possibility' do - scope.function_pick_default(['', :undefined, :undef]).should == :undef + expect(scope.function_pick_default(['', :undefined, :undef])).to eq(:undef) end it 'should return :undefined if it is the last possibility' do - scope.function_pick_default([:undef, '', :undefined]).should == :undefined + expect(scope.function_pick_default([:undef, '', :undefined])).to eq(:undefined) end it 'should return the empty string if it is the only possibility' do - scope.function_pick_default(['']).should == '' + expect(scope.function_pick_default([''])).to eq('') end it 'should return :undef if it is the only possibility' do - scope.function_pick_default([:undef]).should == :undef + expect(scope.function_pick_default([:undef])).to eq(:undef) end it 'should return :undefined if it is the only possibility' do - scope.function_pick_default([:undefined]).should == :undefined + expect(scope.function_pick_default([:undefined])).to eq(:undefined) end it 'should error if no values are passed' do diff --git a/stdlib/spec/unit/puppet/parser/functions/pick_spec.rb b/stdlib/spec/functions/pick_spec.rb similarity index 60% rename from stdlib/spec/unit/puppet/parser/functions/pick_spec.rb rename to stdlib/spec/functions/pick_spec.rb index f53fa8000..8be8f5875 100755 --- a/stdlib/spec/unit/puppet/parser/functions/pick_spec.rb +++ b/stdlib/spec/functions/pick_spec.rb @@ -5,27 +5,27 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("pick").should == "function_pick" + expect(Puppet::Parser::Functions.function("pick")).to eq("function_pick") end it 'should return the correct value' do - scope.function_pick(['first', 'second']).should == 'first' + expect(scope.function_pick(['first', 'second'])).to eq('first') end it 'should return the correct value if the first value is empty' do - scope.function_pick(['', 'second']).should == 'second' + expect(scope.function_pick(['', 'second'])).to eq('second') end it 'should remove empty string values' do - scope.function_pick(['', 'first']).should == 'first' + expect(scope.function_pick(['', 'first'])).to eq('first') end it 'should remove :undef values' do - scope.function_pick([:undef, 'first']).should == 'first' + expect(scope.function_pick([:undef, 'first'])).to eq('first') end it 'should remove :undefined values' do - scope.function_pick([:undefined, 'first']).should == 'first' + expect(scope.function_pick([:undefined, 'first'])).to eq('first') end it 'should error if no values are passed' do diff --git a/stdlib/spec/unit/puppet/parser/functions/prefix_spec.rb b/stdlib/spec/functions/prefix_spec.rb old mode 100644 new mode 100755 similarity index 95% rename from stdlib/spec/unit/puppet/parser/functions/prefix_spec.rb rename to stdlib/spec/functions/prefix_spec.rb index 6e8ddc58e..34cac5305 --- a/stdlib/spec/unit/puppet/parser/functions/prefix_spec.rb +++ b/stdlib/spec/functions/prefix_spec.rb @@ -23,6 +23,6 @@ it "returns a prefixed array" do result = scope.function_prefix([['a','b','c'], 'p']) - result.should(eq(['pa','pb','pc'])) + expect(result).to(eq(['pa','pb','pc'])) end end diff --git a/stdlib/spec/functions/private_spec.rb b/stdlib/spec/functions/private_spec.rb new file mode 100755 index 000000000..c70759fa8 --- /dev/null +++ b/stdlib/spec/functions/private_spec.rb @@ -0,0 +1,55 @@ +#! /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 + + 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/range_spec.rb b/stdlib/spec/functions/range_spec.rb old mode 100644 new mode 100755 similarity index 58% rename from stdlib/spec/unit/puppet/parser/functions/range_spec.rb rename to stdlib/spec/functions/range_spec.rb index 0e1ad376f..ef86f9719 --- a/stdlib/spec/unit/puppet/parser/functions/range_spec.rb +++ b/stdlib/spec/functions/range_spec.rb @@ -5,7 +5,7 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "exists" do - Puppet::Parser::Functions.function("range").should == "function_range" + expect(Puppet::Parser::Functions.function("range")).to eq("function_range") end it "raises a ParseError if there is less than 1 arguments" do @@ -15,56 +15,72 @@ describe 'with a letter range' do it "returns a letter range" do result = scope.function_range(["a","d"]) - result.should eq ['a','b','c','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"]) - result.should eq ['a','b','c','d'] + expect(result).to eq ['a','b','c','d'] end it "returns a stepped letter range" do result = scope.function_range(["a","d","2"]) - result.should eq ['a','c'] + 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"]) - result.should eq ['a','c'] + 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"]) - result.should eq [1,2,3,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"]) - result.should eq [1,2,3,4] + expect(result).to eq [1,2,3,4] end it "returns a stepped number range" do result = scope.function_range(["1","4","2"]) - result.should eq [1,3] + 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"]) - result.should eq [1,3] + 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 - scope.function_range(["host01","host10"]).should eq expected + expect(scope.function_range(["host01","host10"])).to eq expected end it "coerces zero padded digits to integers" do expected = (0..10).to_a - scope.function_range(["00", "10"]).should eq expected + 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/reject_spec.rb b/stdlib/spec/functions/reject_spec.rb similarity index 64% rename from stdlib/spec/unit/puppet/parser/functions/reject_spec.rb rename to stdlib/spec/functions/reject_spec.rb index f2cb74193..88a992efc 100755 --- a/stdlib/spec/unit/puppet/parser/functions/reject_spec.rb +++ b/stdlib/spec/functions/reject_spec.rb @@ -6,15 +6,15 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("reject").should == "function_reject" + expect(Puppet::Parser::Functions.function("reject")).to eq("function_reject") end it "should raise a ParseError if there is less than 1 arguments" do - lambda { scope.function_reject([]) }.should( raise_error(Puppet::ParseError)) + 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"]) - result.should(eq(["1111", "dddeee"])) + expect(result).to(eq(["1111", "dddeee"])) end end diff --git a/stdlib/spec/functions/reverse_spec.rb b/stdlib/spec/functions/reverse_spec.rb new file mode 100755 index 000000000..1f047943f --- /dev/null +++ b/stdlib/spec/functions/reverse_spec.rb @@ -0,0 +1,28 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/rstrip_spec.rb b/stdlib/spec/functions/rstrip_spec.rb old mode 100644 new mode 100755 similarity index 53% rename from stdlib/spec/unit/puppet/parser/functions/rstrip_spec.rb rename to stdlib/spec/functions/rstrip_spec.rb index d90de1d06..f6b483896 --- a/stdlib/spec/unit/puppet/parser/functions/rstrip_spec.rb +++ b/stdlib/spec/functions/rstrip_spec.rb @@ -5,20 +5,29 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("rstrip").should == "function_rstrip" + expect(Puppet::Parser::Functions.function("rstrip")).to eq("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)) + expect { scope.function_rstrip([]) }.to( raise_error(Puppet::ParseError)) end it "should rstrip a string" do result = scope.function_rstrip(["asdf "]) - result.should(eq('asdf')) + expect(result).to(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'])) + 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/shuffle_spec.rb b/stdlib/spec/functions/shuffle_spec.rb old mode 100644 new mode 100755 similarity index 55% rename from stdlib/spec/unit/puppet/parser/functions/shuffle_spec.rb rename to stdlib/spec/functions/shuffle_spec.rb index 93346d537..a62c1fb5e --- a/stdlib/spec/unit/puppet/parser/functions/shuffle_spec.rb +++ b/stdlib/spec/functions/shuffle_spec.rb @@ -5,20 +5,29 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("shuffle").should == "function_shuffle" + expect(Puppet::Parser::Functions.function("shuffle")).to eq("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)) + 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"]) - result.size.should(eq(4)) + 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"]) - result.split("").sort.join("").should(eq("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 diff --git a/stdlib/spec/unit/puppet/parser/functions/size_spec.rb b/stdlib/spec/functions/size_spec.rb old mode 100644 new mode 100755 similarity index 67% rename from stdlib/spec/unit/puppet/parser/functions/size_spec.rb rename to stdlib/spec/functions/size_spec.rb index b1c435a30..18eb48f96 --- a/stdlib/spec/unit/puppet/parser/functions/size_spec.rb +++ b/stdlib/spec/functions/size_spec.rb @@ -5,20 +5,20 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("size").should == "function_size" + expect(Puppet::Parser::Functions.function("size")).to eq("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)) + expect { scope.function_size([]) }.to( raise_error(Puppet::ParseError)) end it "should return the size of a string" do result = scope.function_size(["asdf"]) - result.should(eq(4)) + expect(result).to(eq(4)) end it "should return the size of an array" do result = scope.function_size([["a","b","c"]]) - result.should(eq(3)) + expect(result).to(eq(3)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/sort_spec.rb b/stdlib/spec/functions/sort_spec.rb old mode 100644 new mode 100755 similarity index 63% rename from stdlib/spec/unit/puppet/parser/functions/sort_spec.rb rename to stdlib/spec/functions/sort_spec.rb index 3187a5aec..4c2a66cf8 --- a/stdlib/spec/unit/puppet/parser/functions/sort_spec.rb +++ b/stdlib/spec/functions/sort_spec.rb @@ -5,20 +5,20 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("sort").should == "function_sort" + expect(Puppet::Parser::Functions.function("sort")).to eq("function_sort") end it "should raise a ParseError if there is not 1 arguments" do - lambda { scope.function_sort(['','']) }.should( raise_error(Puppet::ParseError)) + expect { scope.function_sort(['','']) }.to( raise_error(Puppet::ParseError)) end it "should sort an array" do result = scope.function_sort([["a","c","b"]]) - result.should(eq(['a','b','c'])) + expect(result).to(eq(['a','b','c'])) end it "should sort a string" do result = scope.function_sort(["acb"]) - result.should(eq('abc')) + expect(result).to(eq('abc')) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/squeeze_spec.rb b/stdlib/spec/functions/squeeze_spec.rb old mode 100644 new mode 100755 similarity index 66% rename from stdlib/spec/unit/puppet/parser/functions/squeeze_spec.rb rename to stdlib/spec/functions/squeeze_spec.rb index 60e5a3028..cd0eb37fc --- a/stdlib/spec/unit/puppet/parser/functions/squeeze_spec.rb +++ b/stdlib/spec/functions/squeeze_spec.rb @@ -5,20 +5,20 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("squeeze").should == "function_squeeze" + expect(Puppet::Parser::Functions.function("squeeze")).to eq("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)) + expect { scope.function_squeeze([]) }.to( raise_error(Puppet::ParseError)) end it "should squeeze a string" do result = scope.function_squeeze(["aaabbbbcccc"]) - result.should(eq('abc')) + expect(result).to(eq('abc')) end it "should squeeze all elements in an array" do result = scope.function_squeeze([["aaabbbbcccc","dddfff"]]) - result.should(eq(['abc','df'])) + expect(result).to(eq(['abc','df'])) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/str2bool_spec.rb b/stdlib/spec/functions/str2bool_spec.rb old mode 100644 new mode 100755 similarity index 67% rename from stdlib/spec/unit/puppet/parser/functions/str2bool_spec.rb rename to stdlib/spec/functions/str2bool_spec.rb index 73c09c729..1d205d75d --- a/stdlib/spec/unit/puppet/parser/functions/str2bool_spec.rb +++ b/stdlib/spec/functions/str2bool_spec.rb @@ -5,27 +5,27 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("str2bool").should == "function_str2bool" + expect(Puppet::Parser::Functions.function("str2bool")).to eq("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)) + expect { scope.function_str2bool([]) }.to( raise_error(Puppet::ParseError)) end it "should convert string 'true' to true" do result = scope.function_str2bool(["true"]) - result.should(eq(true)) + expect(result).to(eq(true)) end it "should convert string 'undef' to false" do result = scope.function_str2bool(["undef"]) - result.should(eq(false)) + expect(result).to(eq(false)) end it "should return the boolean it was called with" do result = scope.function_str2bool([true]) - result.should(eq(true)) + expect(result).to(eq(true)) result = scope.function_str2bool([false]) - result.should(eq(false)) + expect(result).to(eq(false)) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/str2saltedsha512_spec.rb b/stdlib/spec/functions/str2saltedsha512_spec.rb old mode 100644 new mode 100755 similarity index 89% rename from stdlib/spec/unit/puppet/parser/functions/str2saltedsha512_spec.rb rename to stdlib/spec/functions/str2saltedsha512_spec.rb index df8fb8e90..ab7f57f11 --- a/stdlib/spec/unit/puppet/parser/functions/str2saltedsha512_spec.rb +++ b/stdlib/spec/functions/str2saltedsha512_spec.rb @@ -5,7 +5,7 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("str2saltedsha512").should == "function_str2saltedsha512" + expect(Puppet::Parser::Functions.function("str2saltedsha512")).to eq("function_str2saltedsha512") end it "should raise a ParseError if there is less than 1 argument" do @@ -18,7 +18,7 @@ it "should return a salted-sha512 password hash 136 characters in length" do result = scope.function_str2saltedsha512(["password"]) - result.length.should(eq(136)) + expect(result.length).to(eq(136)) end it "should raise an error if you pass a non-string password" do @@ -40,6 +40,6 @@ # 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] - result.should == password_hash + expect(result).to eq(password_hash) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/strftime_spec.rb b/stdlib/spec/functions/strftime_spec.rb old mode 100644 new mode 100755 similarity index 65% rename from stdlib/spec/unit/puppet/parser/functions/strftime_spec.rb rename to stdlib/spec/functions/strftime_spec.rb index df42b6f26..ebec54b80 --- a/stdlib/spec/unit/puppet/parser/functions/strftime_spec.rb +++ b/stdlib/spec/functions/strftime_spec.rb @@ -5,25 +5,25 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("strftime").should == "function_strftime" + expect(Puppet::Parser::Functions.function("strftime")).to eq("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)) + 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"]) - result.to_i.should(be > 1311953157) + expect(result.to_i).to(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) + 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"]) - result.should =~ /^\d{4}-\d{2}-\d{2}$/ + expect(result).to match(/^\d{4}-\d{2}-\d{2}$/) end end diff --git a/stdlib/spec/functions/strip_spec.rb b/stdlib/spec/functions/strip_spec.rb new file mode 100755 index 000000000..4ac8daf86 --- /dev/null +++ b/stdlib/spec/functions/strip_spec.rb @@ -0,0 +1,27 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/suffix_spec.rb b/stdlib/spec/functions/suffix_spec.rb old mode 100644 new mode 100755 similarity index 95% rename from stdlib/spec/unit/puppet/parser/functions/suffix_spec.rb rename to stdlib/spec/functions/suffix_spec.rb index 89ba3b823..c7783c64d --- a/stdlib/spec/unit/puppet/parser/functions/suffix_spec.rb +++ b/stdlib/spec/functions/suffix_spec.rb @@ -22,6 +22,6 @@ it "returns a suffixed array" do result = scope.function_suffix([['a','b','c'], 'p']) - result.should(eq(['ap','bp','cp'])) + expect(result).to(eq(['ap','bp','cp'])) end end diff --git a/stdlib/spec/functions/swapcase_spec.rb b/stdlib/spec/functions/swapcase_spec.rb new file mode 100755 index 000000000..791d1dfae --- /dev/null +++ b/stdlib/spec/functions/swapcase_spec.rb @@ -0,0 +1,28 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/time_spec.rb b/stdlib/spec/functions/time_spec.rb old mode 100644 new mode 100755 similarity index 65% rename from stdlib/spec/unit/puppet/parser/functions/time_spec.rb rename to stdlib/spec/functions/time_spec.rb index e9fb76e6a..6e22515f1 --- a/stdlib/spec/unit/puppet/parser/functions/time_spec.rb +++ b/stdlib/spec/functions/time_spec.rb @@ -5,25 +5,25 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("time").should == "function_time" + expect(Puppet::Parser::Functions.function("time")).to eq("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)) + expect { scope.function_time(['','']) }.to( raise_error(Puppet::ParseError)) end it "should return a number" do result = scope.function_time([]) - result.should be_an(Integer) + expect(result).to be_an(Integer) end it "should be higher then when I wrote this test" do result = scope.function_time([]) - result.should(be > 1311953157) + expect(result).to(be > 1311953157) end it "should be lower then 1.5 trillion" do result = scope.function_time([]) - result.should(be < 1500000000) + expect(result).to(be < 1500000000) end end diff --git a/stdlib/spec/functions/to_bytes_spec.rb b/stdlib/spec/functions/to_bytes_spec.rb new file mode 100755 index 000000000..0f6ade912 --- /dev/null +++ b/stdlib/spec/functions/to_bytes_spec.rb @@ -0,0 +1,83 @@ +#! /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 diff --git a/stdlib/spec/functions/type3x_spec.rb b/stdlib/spec/functions/type3x_spec.rb new file mode 100644 index 000000000..d21236a61 --- /dev/null +++ b/stdlib/spec/functions/type3x_spec.rb @@ -0,0 +1,43 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/type_spec.rb b/stdlib/spec/functions/type_spec.rb old mode 100644 new mode 100755 similarity index 57% rename from stdlib/spec/unit/puppet/parser/functions/type_spec.rb rename to stdlib/spec/functions/type_spec.rb index 8fec88f26..b683fcfa4 --- a/stdlib/spec/unit/puppet/parser/functions/type_spec.rb +++ b/stdlib/spec/functions/type_spec.rb @@ -4,40 +4,41 @@ describe "the type function" do let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("type").should == "function_type" + expect(Puppet::Parser::Functions.function("type")).to eq("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)) + 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"]) - result.should(eq('string')) + expect(result).to(eq('string')) end it "should return array when given an array" do result = scope.function_type([["aaabbbbcccc","asdf"]]) - result.should(eq('array')) + expect(result).to(eq('array')) end it "should return hash when given a hash" do result = scope.function_type([{"a"=>1,"b"=>2}]) - result.should(eq('hash')) + expect(result).to(eq('hash')) end it "should return integer when given an integer" do result = scope.function_type(["1"]) - result.should(eq('integer')) + expect(result).to(eq('integer')) end it "should return float when given a float" do result = scope.function_type(["1.34"]) - result.should(eq('float')) + expect(result).to(eq('float')) end it "should return boolean when given a boolean" do result = scope.function_type([true]) - result.should(eq('boolean')) + expect(result).to(eq('boolean')) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/union_spec.rb b/stdlib/spec/functions/union_spec.rb old mode 100644 new mode 100755 similarity index 64% rename from stdlib/spec/unit/puppet/parser/functions/union_spec.rb rename to stdlib/spec/functions/union_spec.rb index 0d282caa6..706f4cbcd --- a/stdlib/spec/unit/puppet/parser/functions/union_spec.rb +++ b/stdlib/spec/functions/union_spec.rb @@ -5,15 +5,15 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("union").should == "function_union" + expect(Puppet::Parser::Functions.function("union")).to eq("function_union") end it "should raise a ParseError if there are fewer than 2 arguments" do - lambda { scope.function_union([]) }.should( raise_error(Puppet::ParseError) ) + 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"]]) - result.should(eq(["a","b","c","d"])) + expect(result).to(eq(["a","b","c","d"])) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/unique_spec.rb b/stdlib/spec/functions/unique_spec.rb old mode 100644 new mode 100755 similarity index 55% rename from stdlib/spec/unit/puppet/parser/functions/unique_spec.rb rename to stdlib/spec/functions/unique_spec.rb index 5d48d49b7..7cd3a566f --- a/stdlib/spec/unit/puppet/parser/functions/unique_spec.rb +++ b/stdlib/spec/functions/unique_spec.rb @@ -5,20 +5,29 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("unique").should == "function_unique" + expect(Puppet::Parser::Functions.function("unique")).to eq("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)) + expect { scope.function_unique([]) }.to( raise_error(Puppet::ParseError)) end it "should remove duplicate elements in a string" do result = scope.function_unique(["aabbc"]) - result.should(eq('abc')) + expect(result).to(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'])) + 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/upcase_spec.rb b/stdlib/spec/functions/upcase_spec.rb old mode 100644 new mode 100755 similarity index 54% rename from stdlib/spec/unit/puppet/parser/functions/upcase_spec.rb rename to stdlib/spec/functions/upcase_spec.rb index 5db55138a..3cf8b0552 --- a/stdlib/spec/unit/puppet/parser/functions/upcase_spec.rb +++ b/stdlib/spec/functions/upcase_spec.rb @@ -5,20 +5,29 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("upcase").should == "function_upcase" + expect(Puppet::Parser::Functions.function("upcase")).to eq("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)) + expect { scope.function_upcase([]) }.to( raise_error(Puppet::ParseError)) end it "should upcase a string" do result = scope.function_upcase(["abc"]) - result.should(eq('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 end diff --git a/stdlib/spec/unit/puppet/parser/functions/uriescape_spec.rb b/stdlib/spec/functions/uriescape_spec.rb old mode 100644 new mode 100755 similarity index 50% rename from stdlib/spec/unit/puppet/parser/functions/uriescape_spec.rb rename to stdlib/spec/functions/uriescape_spec.rb index 7211c8878..2321e5aba --- a/stdlib/spec/unit/puppet/parser/functions/uriescape_spec.rb +++ b/stdlib/spec/functions/uriescape_spec.rb @@ -5,20 +5,29 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("uriescape").should == "function_uriescape" + expect(Puppet::Parser::Functions.function("uriescape")).to eq("function_uriescape") end it "should raise a ParseError if there is less than 1 arguments" do - lambda { scope.function_uriescape([]) }.should( raise_error(Puppet::ParseError)) + expect { scope.function_uriescape([]) }.to( raise_error(Puppet::ParseError)) end it "should uriescape a string" do result = scope.function_uriescape([":/?#[]@!$&'()*+,;= \"{}"]) - result.should(eq(':/?%23[]@!$&\'()*+,;=%20%22%7B%7D')) + expect(result).to(eq(':/?%23[]@!$&\'()*+,;=%20%22%7B%7D')) end it "should do nothing if a string is already safe" do result = scope.function_uriescape(["ABCdef"]) - result.should(eq('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 diff --git a/stdlib/spec/unit/puppet/parser/functions/validate_absolute_path_spec.rb b/stdlib/spec/functions/validate_absolute_path_spec.rb old mode 100644 new mode 100755 similarity index 71% rename from stdlib/spec/unit/puppet/parser/functions/validate_absolute_path_spec.rb rename to stdlib/spec/functions/validate_absolute_path_spec.rb index 1c9cce205..36c836bdb --- a/stdlib/spec/unit/puppet/parser/functions/validate_absolute_path_spec.rb +++ b/stdlib/spec/functions/validate_absolute_path_spec.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'spec_helper' describe Puppet::Parser::Functions.function(:validate_absolute_path) do @@ -38,6 +39,11 @@ def self.valid_paths 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 @@ -46,6 +52,11 @@ def self.valid_paths 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 @@ -54,6 +65,7 @@ def self.valid_paths [ nil, [ nil ], + [ nil, nil ], { 'foo' => 'bar' }, { }, '', @@ -65,19 +77,28 @@ def self.valid_paths end context 'Relative paths' do - %w{ - relative1 - . - .. - ./foo - ../foo - etc/puppetlabs/puppet - opt/puppet/bin - }.each do |path| + 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 + diff --git a/stdlib/spec/unit/puppet/parser/functions/validate_array_spec.rb b/stdlib/spec/functions/validate_array_spec.rb old mode 100644 new mode 100755 similarity index 100% rename from stdlib/spec/unit/puppet/parser/functions/validate_array_spec.rb rename to stdlib/spec/functions/validate_array_spec.rb diff --git a/stdlib/spec/unit/puppet/parser/functions/validate_augeas_spec.rb b/stdlib/spec/functions/validate_augeas_spec.rb old mode 100644 new mode 100755 similarity index 99% rename from stdlib/spec/unit/puppet/parser/functions/validate_augeas_spec.rb rename to stdlib/spec/functions/validate_augeas_spec.rb index ab5c140d1..c695ba2eb --- a/stdlib/spec/unit/puppet/parser/functions/validate_augeas_spec.rb +++ b/stdlib/spec/functions/validate_augeas_spec.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'spec_helper' describe Puppet::Parser::Functions.function(:validate_augeas), :if => Puppet.features.augeas? do diff --git a/stdlib/spec/unit/puppet/parser/functions/validate_bool_spec.rb b/stdlib/spec/functions/validate_bool_spec.rb old mode 100644 new mode 100755 similarity index 98% rename from stdlib/spec/unit/puppet/parser/functions/validate_bool_spec.rb rename to stdlib/spec/functions/validate_bool_spec.rb index 261fb2352..a352d3b55 --- a/stdlib/spec/unit/puppet/parser/functions/validate_bool_spec.rb +++ b/stdlib/spec/functions/validate_bool_spec.rb @@ -1,4 +1,4 @@ -#! /usr/bin/env/ruby -S rspec +#! /usr/bin/env ruby -S rspec require 'spec_helper' diff --git a/stdlib/spec/functions/validate_cmd_spec.rb b/stdlib/spec/functions/validate_cmd_spec.rb new file mode 100755 index 000000000..7cb9782d6 --- /dev/null +++ b/stdlib/spec/functions/validate_cmd_spec.rb @@ -0,0 +1,85 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/validate_hash_spec.rb b/stdlib/spec/functions/validate_hash_spec.rb old mode 100644 new mode 100755 similarity index 100% rename from stdlib/spec/unit/puppet/parser/functions/validate_hash_spec.rb rename to stdlib/spec/functions/validate_hash_spec.rb diff --git a/stdlib/spec/unit/puppet/parser/functions/validate_ipv4_address_spec.rb b/stdlib/spec/functions/validate_ipv4_address_spec.rb old mode 100644 new mode 100755 similarity index 98% rename from stdlib/spec/unit/puppet/parser/functions/validate_ipv4_address_spec.rb rename to stdlib/spec/functions/validate_ipv4_address_spec.rb index 85536d364..45401a423 --- a/stdlib/spec/unit/puppet/parser/functions/validate_ipv4_address_spec.rb +++ b/stdlib/spec/functions/validate_ipv4_address_spec.rb @@ -1,4 +1,4 @@ -#! /usr/bin/env/ruby -S rspec +#! /usr/bin/env ruby -S rspec require "spec_helper" diff --git a/stdlib/spec/unit/puppet/parser/functions/validate_ipv6_address_spec.rb b/stdlib/spec/functions/validate_ipv6_address_spec.rb old mode 100644 new mode 100755 similarity index 98% rename from stdlib/spec/unit/puppet/parser/functions/validate_ipv6_address_spec.rb rename to stdlib/spec/functions/validate_ipv6_address_spec.rb index 1fe530468..a839d902c --- a/stdlib/spec/unit/puppet/parser/functions/validate_ipv6_address_spec.rb +++ b/stdlib/spec/functions/validate_ipv6_address_spec.rb @@ -1,4 +1,4 @@ -#! /usr/bin/env/ruby -S rspec +#! /usr/bin/env ruby -S rspec require "spec_helper" diff --git a/stdlib/spec/unit/puppet/parser/functions/validate_re_spec.rb b/stdlib/spec/functions/validate_re_spec.rb old mode 100644 new mode 100755 similarity index 98% rename from stdlib/spec/unit/puppet/parser/functions/validate_re_spec.rb rename to stdlib/spec/functions/validate_re_spec.rb index d189efb66..d29988bf0 --- a/stdlib/spec/unit/puppet/parser/functions/validate_re_spec.rb +++ b/stdlib/spec/functions/validate_re_spec.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'spec_helper' describe Puppet::Parser::Functions.function(:validate_re) do diff --git a/stdlib/spec/unit/puppet/parser/functions/validate_slength_spec.rb b/stdlib/spec/functions/validate_slength_spec.rb similarity index 96% rename from stdlib/spec/unit/puppet/parser/functions/validate_slength_spec.rb rename to stdlib/spec/functions/validate_slength_spec.rb index 851835fa1..e23f61a20 100755 --- a/stdlib/spec/unit/puppet/parser/functions/validate_slength_spec.rb +++ b/stdlib/spec/functions/validate_slength_spec.rb @@ -6,7 +6,7 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("validate_slength").should == "function_validate_slength" + expect(Puppet::Parser::Functions.function("validate_slength")).to eq("function_validate_slength") end describe "validating the input argument types" do diff --git a/stdlib/spec/unit/puppet/parser/functions/validate_string_spec.rb b/stdlib/spec/functions/validate_string_spec.rb old mode 100644 new mode 100755 similarity index 100% rename from stdlib/spec/unit/puppet/parser/functions/validate_string_spec.rb rename to stdlib/spec/functions/validate_string_spec.rb diff --git a/stdlib/spec/unit/puppet/parser/functions/values_at_spec.rb b/stdlib/spec/functions/values_at_spec.rb old mode 100644 new mode 100755 similarity index 69% rename from stdlib/spec/unit/puppet/parser/functions/values_at_spec.rb rename to stdlib/spec/functions/values_at_spec.rb index 08e95a567..86e3c31c6 --- a/stdlib/spec/unit/puppet/parser/functions/values_at_spec.rb +++ b/stdlib/spec/functions/values_at_spec.rb @@ -5,34 +5,34 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("values_at").should == "function_values_at" + 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 - lambda { scope.function_values_at([]) }.should( raise_error(Puppet::ParseError)) + 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 - lambda { scope.function_values_at([['a','b'],["3-1"]]) }.should( raise_error(Puppet::ParseError)) + 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"]) - result.should(eq(['b'])) + 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"]) - result.should(eq(['a','b'])) + 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"]]) - result.should(eq(['a','c'])) + 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"]]) - result.should(eq(['a','c','e','f'])) + expect(result).to(eq(['a','c','e','f'])) end end diff --git a/stdlib/spec/unit/puppet/parser/functions/values_spec.rb b/stdlib/spec/functions/values_spec.rb old mode 100644 new mode 100755 similarity index 62% rename from stdlib/spec/unit/puppet/parser/functions/values_spec.rb rename to stdlib/spec/functions/values_spec.rb index 14ae41763..08d21b037 --- a/stdlib/spec/unit/puppet/parser/functions/values_spec.rb +++ b/stdlib/spec/functions/values_spec.rb @@ -5,27 +5,27 @@ let(:scope) { PuppetlabsSpec::PuppetInternals.scope } it "should exist" do - Puppet::Parser::Functions.function("values").should == "function_values" + expect(Puppet::Parser::Functions.function("values")).to eq("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)) + 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 - result.should =~ %w{ 1 2 3 } + 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'}]) - result.should =~ %w{ 1 3 3 } - result.should_not =~ %w{ 1 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 - lambda { scope.function_values([['a','b','c']]) }.should( raise_error(Puppet::ParseError)) + expect { scope.function_values([['a','b','c']]) }.to( raise_error(Puppet::ParseError)) end end diff --git a/stdlib/spec/functions/zip_spec.rb b/stdlib/spec/functions/zip_spec.rb new file mode 100755 index 000000000..f265fcee4 --- /dev/null +++ b/stdlib/spec/functions/zip_spec.rb @@ -0,0 +1,31 @@ +#! /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 diff --git a/stdlib/spec/lib/puppet_spec/compiler.rb b/stdlib/spec/lib/puppet_spec/compiler.rb old mode 100644 new mode 100755 index 22e923de2..2f0ae4d79 --- a/stdlib/spec/lib/puppet_spec/compiler.rb +++ b/stdlib/spec/lib/puppet_spec/compiler.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec module PuppetSpec::Compiler def compile_to_catalog(string, node = Puppet::Node.new('foonode')) Puppet[:code] = string diff --git a/stdlib/spec/lib/puppet_spec/database.rb b/stdlib/spec/lib/puppet_spec/database.rb old mode 100644 new mode 100755 index 069ca158c..f5c234179 --- a/stdlib/spec/lib/puppet_spec/database.rb +++ b/stdlib/spec/lib/puppet_spec/database.rb @@ -1,3 +1,4 @@ +#! /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. diff --git a/stdlib/spec/lib/puppet_spec/files.rb b/stdlib/spec/lib/puppet_spec/files.rb index 65b04aab9..71b38ffed 100755 --- a/stdlib/spec/lib/puppet_spec/files.rb +++ b/stdlib/spec/lib/puppet_spec/files.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'fileutils' require 'tempfile' require 'tmpdir' diff --git a/stdlib/spec/lib/puppet_spec/fixtures.rb b/stdlib/spec/lib/puppet_spec/fixtures.rb index 7f6bc2a8f..81e9775ff 100755 --- a/stdlib/spec/lib/puppet_spec/fixtures.rb +++ b/stdlib/spec/lib/puppet_spec/fixtures.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec module PuppetSpec::Fixtures def fixtures(*rest) File.join(PuppetSpec::FIXTURE_DIR, *rest) diff --git a/stdlib/spec/lib/puppet_spec/matchers.rb b/stdlib/spec/lib/puppet_spec/matchers.rb old mode 100644 new mode 100755 index 448bd1811..093d77c81 --- a/stdlib/spec/lib/puppet_spec/matchers.rb +++ b/stdlib/spec/lib/puppet_spec/matchers.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'stringio' ######################################################################## diff --git a/stdlib/spec/lib/puppet_spec/modules.rb b/stdlib/spec/lib/puppet_spec/modules.rb old mode 100644 new mode 100755 index 6835e4434..910c6d94e --- a/stdlib/spec/lib/puppet_spec/modules.rb +++ b/stdlib/spec/lib/puppet_spec/modules.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec module PuppetSpec::Modules class << self def create(name, dir, options = {}) diff --git a/stdlib/spec/lib/puppet_spec/pops.rb b/stdlib/spec/lib/puppet_spec/pops.rb old mode 100644 new mode 100755 index 442c85ba6..e056a52b7 --- a/stdlib/spec/lib/puppet_spec/pops.rb +++ b/stdlib/spec/lib/puppet_spec/pops.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec module PuppetSpec::Pops extend RSpec::Matchers::DSL diff --git a/stdlib/spec/lib/puppet_spec/scope.rb b/stdlib/spec/lib/puppet_spec/scope.rb old mode 100644 new mode 100755 index c14ab4755..3847ede18 --- a/stdlib/spec/lib/puppet_spec/scope.rb +++ b/stdlib/spec/lib/puppet_spec/scope.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec module PuppetSpec::Scope # Initialize a new scope suitable for testing. diff --git a/stdlib/spec/lib/puppet_spec/settings.rb b/stdlib/spec/lib/puppet_spec/settings.rb old mode 100644 new mode 100755 index f3dbc4223..8ddcb975f --- a/stdlib/spec/lib/puppet_spec/settings.rb +++ b/stdlib/spec/lib/puppet_spec/settings.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec module PuppetSpec::Settings # It would probably be preferable to refactor defaults.rb such that the real definitions of diff --git a/stdlib/spec/lib/puppet_spec/verbose.rb b/stdlib/spec/lib/puppet_spec/verbose.rb index d9834f2d7..b2683df04 100755 --- a/stdlib/spec/lib/puppet_spec/verbose.rb +++ b/stdlib/spec/lib/puppet_spec/verbose.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec # Support code for running stuff with warnings disabled. module Kernel def with_verbose_disabled diff --git a/stdlib/spec/monkey_patches/alias_should_to_must.rb b/stdlib/spec/monkey_patches/alias_should_to_must.rb index 1a1111799..505e24092 100755 --- a/stdlib/spec/monkey_patches/alias_should_to_must.rb +++ b/stdlib/spec/monkey_patches/alias_should_to_must.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'rspec' class Object diff --git a/stdlib/spec/monkey_patches/publicize_methods.rb b/stdlib/spec/monkey_patches/publicize_methods.rb index f3a1abf40..3ae59f978 100755 --- a/stdlib/spec/monkey_patches/publicize_methods.rb +++ b/stdlib/spec/monkey_patches/publicize_methods.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec # Some monkey-patching to allow us to test private methods. class Class def publicize_methods(*methods) diff --git a/stdlib/spec/spec_helper.rb b/stdlib/spec/spec_helper.rb old mode 100644 new mode 100755 index cf1981b4d..b490ca3c9 --- a/stdlib/spec/spec_helper.rb +++ b/stdlib/spec/spec_helper.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec dir = File.expand_path(File.dirname(__FILE__)) $LOAD_PATH.unshift File.join(dir, 'lib') @@ -8,7 +9,6 @@ module PuppetSpec require 'puppet' require 'rspec-puppet' -require 'simplecov' require 'puppetlabs_spec_helper/module_spec_helper' require 'puppet_spec/verbose' require 'puppet_spec/files' @@ -20,10 +20,6 @@ module PuppetSpec require 'mocha/setup' -SimpleCov.start do - add_filter "/spec/" -end - RSpec.configure do |config| config.before :each do diff --git a/stdlib/spec/spec_helper_acceptance.rb b/stdlib/spec/spec_helper_acceptance.rb old mode 100644 new mode 100755 index 4cefa752f..3203ce9fb --- a/stdlib/spec/spec_helper_acceptance.rb +++ b/stdlib/spec/spec_helper_acceptance.rb @@ -1,16 +1,25 @@ +#! /usr/bin/env ruby -S rspec require 'beaker-rspec' UNSUPPORTED_PLATFORMS = [] -unless ENV['RS_PROVISION'] == 'no' +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| - # Install Puppet - if host.is_pe? - install_pe - else - install_package host, 'rubygems' - on host, 'gem install puppet --no-ri --no-rdoc' - on host, "mkdir -p #{host['distmoduledir']}" + 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 @@ -24,10 +33,18 @@ # Configure all nodes in nodeset c.before :suite do - # Install module and dependencies - puppet_module_install(:source => proj_root, :module_name => 'stdlib') - hosts.each do |host| - shell('/bin/touch /etc/puppet/hiera.yaml') + 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 diff --git a/stdlib/spec/unit/facter/facter_dot_d_spec.rb b/stdlib/spec/unit/facter/facter_dot_d_spec.rb new file mode 100755 index 000000000..0afadb25f --- /dev/null +++ b/stdlib/spec/unit/facter/facter_dot_d_spec.rb @@ -0,0 +1,32 @@ +#! /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 diff --git a/stdlib/spec/unit/facter/pe_required_facts_spec.rb b/stdlib/spec/unit/facter/pe_required_facts_spec.rb deleted file mode 100644 index 85ff6ab93..000000000 --- a/stdlib/spec/unit/facter/pe_required_facts_spec.rb +++ /dev/null @@ -1,70 +0,0 @@ -# Puppet Enterprise requires the following facts to be set in order to operate. -# These facts are set using the file ???? and the two facts are -# `fact_stomp_port`, and `fact_stomp_server`. -# - -require 'spec_helper' - -describe "External facts in /etc/puppetlabs/facter/facts.d/puppet_enterprise_installer.txt" do - context "With Facter 1.6.17 which does not have external facts support" do - before :each do - Facter.stubs(:version).returns("1.6.17") - Facter::Util::Root.stubs(:root?).returns(true) - # Stub out the filesystem for stdlib - Dir.stubs(:entries).with("/etc/puppetlabs/facter/facts.d"). - returns(['puppet_enterprise_installer.txt']) - Dir.stubs(:entries).with("/etc/facter/facts.d").returns([]) - File.stubs(:readlines).with('/etc/puppetlabs/facter/facts.d/puppet_enterprise_installer.txt'). - returns([ - "fact_stomp_port=61613\n", - "fact_stomp_server=puppetmaster.acme.com\n", - "fact_is_puppetagent=true\n", - "fact_is_puppetmaster=false\n", - "fact_is_puppetca=false\n", - "fact_is_puppetconsole=false\n", - ]) - if Facter.collection.respond_to? :load - Facter.collection.load(:facter_dot_d) - else - Facter.collection.loader.load(:facter_dot_d) - end - end - - it 'defines fact_stomp_port' do - Facter.fact(:fact_stomp_port).value.should == '61613' - end - it 'defines fact_stomp_server' do - Facter.fact(:fact_stomp_server).value.should == 'puppetmaster.acme.com' - end - it 'defines fact_is_puppetagent' do - Facter.fact(:fact_is_puppetagent).value.should == 'true' - end - it 'defines fact_is_puppetmaster' do - Facter.fact(:fact_is_puppetmaster).value.should == 'false' - end - it 'defines fact_is_puppetca' do - Facter.fact(:fact_is_puppetca).value.should == 'false' - end - it 'defines fact_is_puppetconsole' do - Facter.fact(:fact_is_puppetconsole).value.should == 'false' - end - end - - [ '1.7.1', '2.0.1' ].each do |v| - context "With Facter #{v} which has external facts support" do - before :each do - Facter.stubs(:version).returns(v) - end - - it 'does not call Facter::Util::DotD.new' do - Facter::Util::DotD.expects(:new).never - - if Facter.collection.respond_to? :load - Facter.collection.load(:facter_dot_d) - else - Facter.collection.loader.load(:facter_dot_d) - end - end - end - end -end diff --git a/stdlib/spec/unit/facter/pe_version_spec.rb b/stdlib/spec/unit/facter/pe_version_spec.rb old mode 100644 new mode 100755 index 931c6d4b0..4d0349e62 --- a/stdlib/spec/unit/facter/pe_version_spec.rb +++ b/stdlib/spec/unit/facter/pe_version_spec.rb @@ -26,23 +26,23 @@ (major,minor,patch) = version.split(".") it "Should return true" do - Facter.fact(:is_pe).value.should == true + expect(Facter.fact(:is_pe).value).to eq(true) end it "Should have a version of #{version}" do - Facter.fact(:pe_version).value.should == version + expect(Facter.fact(:pe_version).value).to eq(version) end it "Should have a major version of #{major}" do - Facter.fact(:pe_major_version).value.should == major + expect(Facter.fact(:pe_major_version).value).to eq(major) end it "Should have a minor version of #{minor}" do - Facter.fact(:pe_minor_version).value.should == minor + expect(Facter.fact(:pe_minor_version).value).to eq(minor) end it "Should have a patch version of #{patch}" do - Facter.fact(:pe_patch_version).value.should == patch + expect(Facter.fact(:pe_patch_version).value).to eq(patch) end end end @@ -54,23 +54,23 @@ end it "is_pe is false" do - Facter.fact(:is_pe).value.should == false + expect(Facter.fact(:is_pe).value).to eq(false) end it "pe_version is nil" do - Facter.fact(:pe_version).value.should be_nil + expect(Facter.fact(:pe_version).value).to be_nil end it "pe_major_version is nil" do - Facter.fact(:pe_major_version).value.should be_nil + expect(Facter.fact(:pe_major_version).value).to be_nil end it "pe_minor_version is nil" do - Facter.fact(:pe_minor_version).value.should be_nil + expect(Facter.fact(:pe_minor_version).value).to be_nil end it "Should have a patch version" do - Facter.fact(:pe_patch_version).value.should be_nil + expect(Facter.fact(:pe_patch_version).value).to be_nil end end end diff --git a/stdlib/spec/unit/facter/root_home_spec.rb b/stdlib/spec/unit/facter/root_home_spec.rb old mode 100644 new mode 100755 index 532fae1f1..98fe14196 --- a/stdlib/spec/unit/facter/root_home_spec.rb +++ b/stdlib/spec/unit/facter/root_home_spec.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'spec_helper' require 'facter/root_home' @@ -8,7 +9,7 @@ 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 + expect(Facter::Util::RootHome.get_root_home).to eq(expected_root_home) end end context "linux" do @@ -17,7 +18,7 @@ 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 + expect(Facter::Util::RootHome.get_root_home).to eq(expected_root_home) end end context "windows" do @@ -25,7 +26,7 @@ Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(nil) end it "should be nil on windows" do - Facter::Util::RootHome.get_root_home.should be_nil + expect(Facter::Util::RootHome.get_root_home).to be_nil end end end @@ -44,7 +45,7 @@ it "should return /var/root" do Facter::Util::Resolution.stubs(:exec).with("dscacheutil -q user -a name root").returns(sample_dscacheutil) - Facter.fact(:root_home).value.should == expected_root_home + expect(Facter.fact(:root_home).value).to eq(expected_root_home) end end diff --git a/stdlib/spec/unit/facter/util/puppet_settings_spec.rb b/stdlib/spec/unit/facter/util/puppet_settings_spec.rb old mode 100644 new mode 100755 index c3ce6ea07..c06137d7e --- a/stdlib/spec/unit/facter/util/puppet_settings_spec.rb +++ b/stdlib/spec/unit/facter/util/puppet_settings_spec.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'spec_helper' require 'facter/util/puppet_settings' @@ -10,11 +11,11 @@ end it 'should be nil' do - subject.with_puppet { Puppet[:vardir] }.should be_nil + expect(subject.with_puppet { Puppet[:vardir] }).to be_nil end it 'should not yield to the block' do Puppet.expects(:[]).never - subject.with_puppet { Puppet[:vardir] }.should be_nil + expect(subject.with_puppet { Puppet[:vardir] }).to be_nil end end context "With Puppet loaded" do @@ -28,7 +29,7 @@ module Puppet; end subject.with_puppet { Puppet[:vardir] } end it 'should return the nodes vardir' do - subject.with_puppet { Puppet[:vardir] }.should eq vardir + expect(subject.with_puppet { Puppet[:vardir] }).to eq vardir end end end diff --git a/stdlib/spec/unit/puppet/functions/type_of_spec.rb b/stdlib/spec/unit/puppet/functions/type_of_spec.rb new file mode 100644 index 000000000..8afb62464 --- /dev/null +++ b/stdlib/spec/unit/puppet/functions/type_of_spec.rb @@ -0,0 +1,33 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/basename_spec.rb b/stdlib/spec/unit/puppet/parser/functions/basename_spec.rb new file mode 100755 index 000000000..8a2d0dc3d --- /dev/null +++ b/stdlib/spec/unit/puppet/parser/functions/basename_spec.rb @@ -0,0 +1,46 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/bool2num_spec.rb b/stdlib/spec/unit/puppet/parser/functions/bool2num_spec.rb deleted file mode 100755 index 518ac85ec..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/bool2num_spec.rb +++ /dev/null @@ -1,24 +0,0 @@ -#! /usr/bin/env ruby -S rspec -require 'spec_helper' - -describe "the bool2num function" do - let(:scope) { PuppetlabsSpec::PuppetInternals.scope } - - 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/bool2str_spec.rb b/stdlib/spec/unit/puppet/parser/functions/bool2str_spec.rb new file mode 100755 index 000000000..b87889180 --- /dev/null +++ b/stdlib/spec/unit/puppet/parser/functions/bool2str_spec.rb @@ -0,0 +1,46 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/camelcase_spec.rb b/stdlib/spec/unit/puppet/parser/functions/camelcase_spec.rb new file mode 100755 index 000000000..70382adb1 --- /dev/null +++ b/stdlib/spec/unit/puppet/parser/functions/camelcase_spec.rb @@ -0,0 +1,24 @@ +#! /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 diff --git a/stdlib/spec/unit/puppet/parser/functions/capitalize_spec.rb b/stdlib/spec/unit/puppet/parser/functions/capitalize_spec.rb deleted file mode 100755 index 69c9758f2..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/capitalize_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -#! /usr/bin/env ruby -S rspec -require 'spec_helper' - -describe "the capitalize function" do - let(:scope) { PuppetlabsSpec::PuppetInternals.scope } - - 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/chop_spec.rb b/stdlib/spec/unit/puppet/parser/functions/chop_spec.rb deleted file mode 100755 index 9e466de4b..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/chop_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -#! /usr/bin/env ruby -S rspec -require 'spec_helper' - -describe "the chop function" do - let(:scope) { PuppetlabsSpec::PuppetInternals.scope } - - 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/concat_spec.rb b/stdlib/spec/unit/puppet/parser/functions/concat_spec.rb deleted file mode 100644 index 123188bd4..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/concat_spec.rb +++ /dev/null @@ -1,15 +0,0 @@ -#! /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 there is less than 1 arguments" do - lambda { scope.function_concat([]) }.should( raise_error(Puppet::ParseError)) - end - - it "should be able to concat an array" do - result = scope.function_concat([['1','2','3'],['4','5','6']]) - result.should(eq(['1','2','3','4','5','6'])) - end -end diff --git a/stdlib/spec/unit/puppet/parser/functions/delete_spec.rb b/stdlib/spec/unit/puppet/parser/functions/delete_spec.rb deleted file mode 100755 index 1508a63e9..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/delete_spec.rb +++ /dev/null @@ -1,56 +0,0 @@ -#! /usr/bin/env ruby -S rspec -require 'spec_helper' - -describe "the delete function" do - let(:scope) { PuppetlabsSpec::PuppetInternals.scope } - - it "should exist" do - Puppet::Parser::Functions.function("delete").should == "function_delete" - end - - it "should raise a ParseError if there are fewer than 2 arguments" do - lambda { scope.function_delete([]) }.should( raise_error(Puppet::ParseError)) - end - - it "should raise a ParseError if there are greater than 2 arguments" do - lambda { scope.function_delete([[], 'foo', 'bar']) }.should( raise_error(Puppet::ParseError)) - end - - it "should raise a TypeError if a number is passed as the first argument" do - lambda { scope.function_delete([1, 'bar']) }.should( 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']) - result.should(eq(['a','c'])) - end - - it "should delete all instances of a substring from a string" do - result = scope.function_delete(['foobarbabarz','bar']) - result.should(eq('foobaz')) - end - - it "should delete a key from a hash" do - result = scope.function_delete([{ 'a' => 1, 'b' => 2, 'c' => 3 },'b']) - result.should(eq({ 'a' => 1, 'c' => 3 })) - end - - it "should not change origin array passed as argument" do - origin_array = ['a','b','c','d'] - result = scope.function_delete([origin_array, 'b']) - origin_array.should(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']) - origin_string.should(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']) - origin_hash.should(eq({ 'a' => 1, 'b' => 2, 'c' => 3 })) - end - -end diff --git a/stdlib/spec/unit/puppet/parser/functions/fqdn_rotate_spec.rb b/stdlib/spec/unit/puppet/parser/functions/fqdn_rotate_spec.rb deleted file mode 100644 index 257772335..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/fqdn_rotate_spec.rb +++ /dev/null @@ -1,33 +0,0 @@ -#! /usr/bin/env ruby -S rspec -require 'spec_helper' - -describe "the fqdn_rotate function" do - let(:scope) { PuppetlabsSpec::PuppetInternals.scope } - - it "should exist" do - Puppet::Parser::Functions.function("fqdn_rotate").should == "function_fqdn_rotate" - end - - it "should raise a ParseError if there is less than 1 arguments" do - lambda { scope.function_fqdn_rotate([]) }.should( 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"]) - result.size.should(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 - scope.function_fqdn_rotate(["abcdefg"]).should 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"]) - val1.should_not eql(val2) - end -end diff --git a/stdlib/spec/unit/puppet/parser/functions/lstrip_spec.rb b/stdlib/spec/unit/puppet/parser/functions/lstrip_spec.rb deleted file mode 100644 index b280ae7ac..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/lstrip_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -#! /usr/bin/env ruby -S rspec -require 'spec_helper' - -describe "the lstrip function" do - let(:scope) { PuppetlabsSpec::PuppetInternals.scope } - - 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/member_spec.rb b/stdlib/spec/unit/puppet/parser/functions/member_spec.rb deleted file mode 100644 index 6e9a023fa..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/member_spec.rb +++ /dev/null @@ -1,24 +0,0 @@ -#! /usr/bin/env ruby -S rspec -require 'spec_helper' - -describe "the member function" do - let(:scope) { PuppetlabsSpec::PuppetInternals.scope } - - 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/reverse_spec.rb b/stdlib/spec/unit/puppet/parser/functions/reverse_spec.rb deleted file mode 100644 index 1b5920654..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/reverse_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -#! /usr/bin/env ruby -S rspec -require 'spec_helper' - -describe "the reverse function" do - let(:scope) { PuppetlabsSpec::PuppetInternals.scope } - - 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/strip_spec.rb b/stdlib/spec/unit/puppet/parser/functions/strip_spec.rb deleted file mode 100644 index fccdd2606..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/strip_spec.rb +++ /dev/null @@ -1,18 +0,0 @@ -#! /usr/bin/env ruby -S rspec -require 'spec_helper' - -describe "the strip function" do - let(:scope) { PuppetlabsSpec::PuppetInternals.scope } - 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/swapcase_spec.rb b/stdlib/spec/unit/puppet/parser/functions/swapcase_spec.rb deleted file mode 100644 index 808b41587..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/swapcase_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -#! /usr/bin/env ruby -S rspec -require 'spec_helper' - -describe "the swapcase function" do - let(:scope) { PuppetlabsSpec::PuppetInternals.scope } - - 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/to_bytes_spec.rb b/stdlib/spec/unit/puppet/parser/functions/to_bytes_spec.rb deleted file mode 100755 index d1ea4c80c..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/to_bytes_spec.rb +++ /dev/null @@ -1,58 +0,0 @@ -#! /usr/bin/env ruby -S rspec - -require 'spec_helper' - -describe "the to_bytes function" do - let(:scope) { PuppetlabsSpec::PuppetInternals.scope } - - it "should exist" do - Puppet::Parser::Functions.function("to_bytes").should == "function_to_bytes" - end - - it "should raise a ParseError if there is less than 1 arguments" do - lambda { scope.function_to_bytes([]) }.should( raise_error(Puppet::ParseError)) - end - - it "should convert kB to B" do - result = scope.function_to_bytes(["4 kB"]) - result.should(eq(4096)) - end - - it "should work without B in unit" do - result = scope.function_to_bytes(["4 k"]) - result.should(eq(4096)) - end - - it "should work without a space before unit" do - result = scope.function_to_bytes(["4k"]) - result.should(eq(4096)) - end - - it "should work without a unit" do - result = scope.function_to_bytes(["5678"]) - result.should(eq(5678)) - end - - it "should convert fractions" do - result = scope.function_to_bytes(["1.5 kB"]) - result.should(eq(1536)) - end - - it "should convert scientific notation" do - result = scope.function_to_bytes(["1.5e2 B"]) - result.should(eq(150)) - end - - it "should do nothing with a positive number" do - result = scope.function_to_bytes([5678]) - result.should(eq(5678)) - end - - it "should should raise a ParseError if input isn't a number" do - lambda { scope.function_to_bytes(["foo"]) }.should( raise_error(Puppet::ParseError)) - end - - it "should should raise a ParseError if prefix is unknown" do - lambda { scope.function_to_bytes(["5 uB"]) }.should( raise_error(Puppet::ParseError)) - end -end diff --git a/stdlib/spec/unit/puppet/parser/functions/validate_cmd_spec.rb b/stdlib/spec/unit/puppet/parser/functions/validate_cmd_spec.rb deleted file mode 100644 index a86cb014c..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/validate_cmd_spec.rb +++ /dev/null @@ -1,47 +0,0 @@ -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 - - 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 diff --git a/stdlib/spec/unit/puppet/parser/functions/zip_spec.rb b/stdlib/spec/unit/puppet/parser/functions/zip_spec.rb deleted file mode 100644 index f45ab1730..000000000 --- a/stdlib/spec/unit/puppet/parser/functions/zip_spec.rb +++ /dev/null @@ -1,15 +0,0 @@ -#! /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 - 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 diff --git a/stdlib/spec/unit/puppet/provider/file_line/ruby_spec.rb b/stdlib/spec/unit/puppet/provider/file_line/ruby_spec.rb old mode 100644 new mode 100755 index c356bd229..d2a129c32 --- a/stdlib/spec/unit/puppet/provider/file_line/ruby_spec.rb +++ b/stdlib/spec/unit/puppet/provider/file_line/ruby_spec.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'spec_helper' require 'tempfile' provider_class = Puppet::Type.type(:file_line).provider(:ruby) @@ -22,17 +23,17 @@ File.open(tmpfile, 'w') do |fh| fh.write('foo') end - provider.exists?.should be_true + 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 - provider.exists?.should be_nil + expect(provider.exists?).to be_nil end it 'should append to an existing file when creating' do provider.create - File.read(tmpfile).chomp.should == 'foo' + expect(File.read(tmpfile).chomp).to eq('foo') end end @@ -60,9 +61,9 @@ File.open(@tmpfile, 'w') do |fh| fh.write("foo1\nfoo=blah\nfoo2\nfoo=baz") end - @provider.exists?.should be_nil + expect(@provider.exists?).to be_nil expect { @provider.create }.to raise_error(Puppet::Error, /More than one line.*matches/) - File.read(@tmpfile).should eql("foo1\nfoo=blah\nfoo2\nfoo=baz") + expect(File.read(@tmpfile)).to eql("foo1\nfoo=blah\nfoo2\nfoo=baz") end it 'should replace all lines that matches' do @@ -79,9 +80,9 @@ File.open(@tmpfile, 'w') do |fh| fh.write("foo1\nfoo=blah\nfoo2\nfoo=baz") end - @provider.exists?.should be_nil + expect(@provider.exists?).to be_nil @provider.create - File.read(@tmpfile).chomp.should eql("foo1\nfoo = bar\nfoo2\nfoo = bar") + expect(File.read(@tmpfile).chomp).to eql("foo1\nfoo = bar\nfoo2\nfoo = bar") end it 'should raise an error with invalid values' do @@ -102,25 +103,25 @@ File.open(@tmpfile, 'w') do |fh| fh.write("foo1\nfoo=blah\nfoo2") end - @provider.exists?.should be_nil + expect(@provider.exists?).to be_nil @provider.create - File.read(@tmpfile).chomp.should eql("foo1\nfoo = bar\nfoo2") + 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 - @provider.exists?.should be_nil + expect(@provider.exists?).to be_nil @provider.create - File.read(@tmpfile).should eql("foo1\nfoo2\nfoo = bar\n") + 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 - @provider.exists?.should be_true + expect(@provider.exists?).to be_truthy @provider.create - File.read(@tmpfile).chomp.should eql("foo1\nfoo = bar\nfoo2") + expect(File.read(@tmpfile).chomp).to eql("foo1\nfoo = bar\nfoo2") end end @@ -149,7 +150,7 @@ it 'inserts the specified line after the line matching the "after" expression' do provider.create - File.read(@tmpfile).chomp.should eql("foo1\ninserted = line\nfoo = blah\nfoo2\nfoo = baz") + expect(File.read(@tmpfile).chomp).to eql("foo1\ninserted = line\nfoo = blah\nfoo2\nfoo = baz") end end @@ -178,7 +179,7 @@ it 'appends the specified line to the file' do provider.create - File.read(@tmpfile).should eq(content << resource[:line] << "\n") + expect(File.read(@tmpfile)).to eq(content << resource[:line] << "\n") end end end @@ -202,7 +203,7 @@ fh.write("foo1\nfoo\nfoo2") end @provider.destroy - File.read(@tmpfile).should eql("foo1\nfoo2") + expect(File.read(@tmpfile)).to eql("foo1\nfoo2") end it 'should remove the line without touching the last new line' do @@ -210,7 +211,7 @@ fh.write("foo1\nfoo\nfoo2\n") end @provider.destroy - File.read(@tmpfile).should eql("foo1\nfoo2\n") + expect(File.read(@tmpfile)).to eql("foo1\nfoo2\n") end it 'should remove any occurence of the line' do @@ -218,7 +219,7 @@ fh.write("foo1\nfoo\nfoo2\nfoo\nfoo") end @provider.destroy - File.read(@tmpfile).should eql("foo1\nfoo2\n") + expect(File.read(@tmpfile)).to eql("foo1\nfoo2\n") end end end diff --git a/stdlib/spec/unit/puppet/type/anchor_spec.rb b/stdlib/spec/unit/puppet/type/anchor_spec.rb old mode 100644 new mode 100755 index f92065f79..c738a272b --- a/stdlib/spec/unit/puppet/type/anchor_spec.rb +++ b/stdlib/spec/unit/puppet/type/anchor_spec.rb @@ -6,6 +6,6 @@ describe anchor do it "should stringify normally" do - anchor.to_s.should == "Anchor[ntp::begin]" + expect(anchor.to_s).to eq("Anchor[ntp::begin]") end end diff --git a/stdlib/spec/unit/puppet/type/file_line_spec.rb b/stdlib/spec/unit/puppet/type/file_line_spec.rb old mode 100644 new mode 100755 index 34d5dada3..410d0bfec --- a/stdlib/spec/unit/puppet/type/file_line_spec.rb +++ b/stdlib/spec/unit/puppet/type/file_line_spec.rb @@ -1,3 +1,4 @@ +#! /usr/bin/env ruby -S rspec require 'spec_helper' require 'tempfile' describe Puppet::Type.type(:file_line) do @@ -6,22 +7,22 @@ end it 'should accept a line and path' do file_line[:line] = 'my_line' - file_line[:line].should == 'my_line' + expect(file_line[:line]).to eq('my_line') file_line[:path] = '/my/path' - file_line[:path].should == '/my/path' + expect(file_line[:path]).to eq('/my/path') end it 'should accept a match regex' do file_line[:match] = '^foo.*$' - file_line[:match].should == '^foo.*$' + expect(file_line[:match]).to eq('^foo.*$') end - it 'should not accept a match regex that does not match the specified line' do + 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$' - )}.to raise_error(Puppet::Error, /the value must be a regex that matches/) + )}.not_to raise_error end it 'should accept a match regex that does match the specified line' do expect { @@ -34,7 +35,7 @@ end it 'should accept posix filenames' do file_line[:path] = '/tmp/path' - file_line[:path].should == '/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/) @@ -46,7 +47,7 @@ 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 - file_line[:ensure].should eq :present + expect(file_line[:ensure]).to eq :present end it "should autorequire the file it manages" do @@ -58,12 +59,12 @@ relationship = file_line.autorequire.find do |rel| (rel.source.to_s == "File[/tmp/path]") and (rel.target.to_s == file_line.to_s) end - relationship.should be_a Puppet::Relationship + 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 - file_line.autorequire.should be_empty + expect(file_line.autorequire).to be_empty end end