inspec-core 2.2.16 → 2.2.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d354cf05e740d0b2e7a605fe1a22b543ed644b42b90a2c1e245d79e49524673d
-  data.tar.gz: d4b7ff00cf12d7667162518314798d6514c6d57e6829adcc918075e5267deb6c
+  metadata.gz: 30bcedf19961b6e6f3d5c4866ce517d14042a5ba0c2cb492da68f94fe9284bac
+  data.tar.gz: cee89f571ddb03d6cfef422cbd1dfb6380f639505c021ef8cda96ac3fc396aa5
 SHA512:
-  metadata.gz: d00d6a382fc7d98812effb6d4fc6a4d20b4ac89c96e7af385a81cb7373bbfcebb1181f99ea06708e7c87e8d1477d29e6f86a632ab97bf92d33e532521eec32c0
-  data.tar.gz: 28bbac8ca3e11bd5fe25b2e7f94bf91035417a7501f1a3354c583d3b7215f30b4699372c93d4cc37eb4e0476515746f632ab2462eb936cd0e017b47d51c51bed
+  metadata.gz: 22f243ab058aa7373298dab9c0604cce20a6490d9374a9dc39d27c575676cf6c1a27065c32e267c54cfa95d864767866464ac6565a8d95608838c140305111d4
+  data.tar.gz: b031ce5c1e573e9652b6beff2055342e1cb0470fa51560589a5e37797cf0040a4d5a2b5cbbeca38e26c4c4860b58e41e751889360ce29934f905503a90b44727

data/CHANGELOG.md

@@ -1,27 +1,38 @@
 # Change Log
 <!-- usage documentation: http://expeditor-docs.es.chef.io/configuration/changelog/ -->
-<!-- latest_release 2.2.16 -->
-## [v2.2.16](https://github.com/inspec/inspec/tree/v2.2.16) (2018-06-15)
+<!-- latest_release 2.2.20 -->
+## [v2.2.20](https://github.com/inspec/inspec/tree/v2.2.20) (2018-06-21)
 
 #### Merged Pull Requests
-- deprecate azure_generic_resource [#3132](https://github.com/inspec/inspec/pull/3132) ([chris-rock](https://github.com/chris-rock))
+- Accept symbols and downcased criteria in aws_iam_policy have_statement matcher [#3129](https://github.com/inspec/inspec/pull/3129) ([clintoncwolfe](https://github.com/clintoncwolfe))
 <!-- latest_release -->
 
-<!-- release_rollup since=2.2.10 -->
-### Changes since 2.2.10 release
-
-#### Enhancements
-- Fix unit tests for ruby 2.5 [#3125](https://github.com/inspec/inspec/pull/3125) ([jquick](https://github.com/jquick)) <!-- 2.2.12 -->
+<!-- release_rollup since=2.2.16 -->
+### Changes since 2.2.16 release
 
 #### Merged Pull Requests
-- deprecate azure_generic_resource [#3132](https://github.com/inspec/inspec/pull/3132) ([chris-rock](https://github.com/chris-rock)) <!-- 2.2.16 -->
-- Bump train version for inspec [#3147](https://github.com/inspec/inspec/pull/3147) ([jquick](https://github.com/jquick)) <!-- 2.2.15 -->
-- Add insecure option to the automate report json [#3124](https://github.com/inspec/inspec/pull/3124) ([jquick](https://github.com/jquick)) <!-- 2.2.14 -->
-- Add list properties back to shadow [#3140](https://github.com/inspec/inspec/pull/3140) ([clintoncwolfe](https://github.com/clintoncwolfe)) <!-- 2.2.13 -->
-- Translate `auditd -s` RHEL output to match CentOS [#3114](https://github.com/inspec/inspec/pull/3114) ([jerryaldrichiii](https://github.com/jerryaldrichiii)) <!-- 2.2.11 -->
+- Accept symbols and downcased criteria in aws_iam_policy have_statement matcher [#3129](https://github.com/inspec/inspec/pull/3129) ([clintoncwolfe](https://github.com/clintoncwolfe)) <!-- 2.2.20 -->
+
+#### Enhancements
+- Fix control merging when overriding child controls [#3155](https://github.com/inspec/inspec/pull/3155) ([jquick](https://github.com/jquick)) <!-- 2.2.19 -->
+- auditd resource: Add handling for sudo/no command [#3151](https://github.com/inspec/inspec/pull/3151) ([jerryaldrichiii](https://github.com/jerryaldrichiii)) <!-- 2.2.18 -->
+- updated skip message to reflect accurate version of audit support [#3153](https://github.com/inspec/inspec/pull/3153) ([jeremymv2](https://github.com/jeremymv2)) <!-- 2.2.17 -->
 <!-- release_rollup -->
 
 <!-- latest_stable_release -->
+## [v2.2.16](https://github.com/inspec/inspec/tree/v2.2.16) (2018-06-15)
+
+#### Enhancements
+- Fix unit tests for ruby 2.5 [#3125](https://github.com/inspec/inspec/pull/3125) ([jquick](https://github.com/jquick))
+
+#### Merged Pull Requests
+- Translate `auditd -s` RHEL output to match CentOS [#3114](https://github.com/inspec/inspec/pull/3114) ([jerryaldrichiii](https://github.com/jerryaldrichiii))
+- Add list properties back to shadow [#3140](https://github.com/inspec/inspec/pull/3140) ([clintoncwolfe](https://github.com/clintoncwolfe))
+- Add insecure option to the automate report json [#3124](https://github.com/inspec/inspec/pull/3124) ([jquick](https://github.com/jquick))
+- Bump train version for inspec [#3147](https://github.com/inspec/inspec/pull/3147) ([jquick](https://github.com/jquick))
+- deprecate azure_generic_resource [#3132](https://github.com/inspec/inspec/pull/3132) ([chris-rock](https://github.com/chris-rock))
+<!-- latest_stable_release -->
+
 ## [v2.2.10](https://github.com/inspec/inspec/tree/v2.2.10) (2018-06-08)
 
 #### New Resources
@@ -44,7 +55,6 @@
 - Add lazy-loading to FilterTable [#3093](https://github.com/inspec/inspec/pull/3093) ([clintoncwolfe](https://github.com/clintoncwolfe))
 - Update Junit.rb to add failures attribute [#3086](https://github.com/inspec/inspec/pull/3086) ([scboucher](https://github.com/scboucher))
 - Clean up issues in documentation [#3058](https://github.com/inspec/inspec/pull/3058) ([miah](https://github.com/miah))
-<!-- latest_stable_release -->
 
 ## [v2.1.84](https://github.com/inspec/inspec/tree/v2.1.84) (2018-05-31)
 

data/docs/glossary.md

@@ -1,99 +1,381 @@
 # InSpec Glossary
 
-## Basic Syntax
+This document should help you become familiar with some of the terminology used by the InSpec project.
+
+There are two ways to use it:
+
+* A [text glossary](#text_glossary). Learn the meaning of a word you have encountered.
+* A [visual glossary](#visual_glossary). Look at examples and see how the parts are labelled. You can then use the text glossary to read details of each concept.
+
+## Visual Glossary
+
+### Motivating Example
+
+Suppose we are interested in auditing cars. Let's suppose we have two InSpec resources for auditing: `cars`, which searchs for and filters groups of cars, and `car`, which performs detailed auditing of a single car.
+
+### Basic Syntax
+
+Let's look at some simple examples.
+
+### Singular Resource Example
+
+```inspec
+describe car(owner: 'Tony Clifton') do
+    it { should exist }
+    its('license_plate') { should cmp 'MOONMAN' }
+    it { should be_classy }
+    it { should_not have_check_engine_light_on }
+end
 ```
-describe foo('/path/to/foo.txt') do
-    its('blah') { should cmp '123' }
+
+#### describe car(owner: 'Tony Clifton') do
+
+_car_ is a [resource](#resource). Since we are talking about only one car, it is a [singular resource](#singular_resource).
+
+#### describe car(_owner: 'Tony Clifton'_)
+
+_owner_ is a [resource parameter](#resource_parameter) and _'Tony Clifton'_ is a resource parameter value.
+
+#### _it { should exist }_
+
+Each line within the resource block beginning with `it` or `its` is a [test](#test). Use [it](#it) to access [resource-specific matchers](#resource_specific_matcher), and use [its](#its) to access [properties](#property) of the [resource](#resource), which are in turn used with [universal matchers](#universal_matcher).
+
+#### its('_license\_plate_') { should cmp 'MOONMAN' }
+
+_license\_plate_ is a [property](#property) belonging to the [resource](#resource). Properties expose testable information about the resource. Some properties are numbers, some (like this one) are text, some are lists, and some are more complex objects. Properties are always used with [universal matchers](#universal_matcher).
+
+#### its('license\_plate') { should _cmp_ 'MOONMAN' }
+
+_cmp_ is a [universal matcher](#universal_matcher). `cmp` is a very flexible, loosely typed equality operator; here it checks to see if the license plate text is the same as the text 'MOONMAN'. Notice that the test operates on the license plate text (the property value) and not on the resource. You can find the full list of supported universal matchers on the [Universal Matcher page](https://www.inspec.io/docs/reference/matchers/).
+
+#### its('license\_plate') { should cmp _'MOONMAN'_ }
+
+_'MOONMAN'_ is an [expected result](#expected_result). Some matchers take an expected result; others do not.
+
+#### it { should _be\_classy_ }
+
+_be\_classy_ is a [resource-specific matcher](#resource_specific_matcher). It returns a yes-or-no value, based on whether Tony's car is classy or not. (It is. Tony is a classy guy.)
+
+#### it { _should\_not_ have\_check\_engine\_light\_on }
+
+_should\_not_ indicates this is a negated test. So, this test passes if the matcher says "no".
+
+### Plural Resource Example
+
+```inspec
+  describe cars.where(color: /^b/) do
     it { should exist }
-    it { should be_reasonable }
-    it { should_not be_ridiculous }
+    its('manufacturers') { should include 'Cadillac' }
+    its('count') { should be >= 10 }
+  end
+```
+
+#### describe _cars_.where(color: /^b/) do
+
+_cars_ is a [resource](#resource). Since we are potentially talking about many cars, it is a [plural resource](#plural_resource).
+
+#### describe cars._where(color: /^b/)_ do
+
+_where(color: /^b/)_ is a [filter statement](#filter_statement). Without a filter statement, `cars` simply selects all the cars in the world.
+
+#### describe cars.where(_color: /^b/_) do
+
+_color_ is a [filter criterion](#filter_criteria) along with its filter value, _/^b/_. Here, the criterion expresses that we want to select all cars whose colors begin with the letter 'b' - blue, brown, burgundy, etc.
+
+#### _it { should exist }_
+
+Each line within the resource block beginning with `it` or `its` is a [test](#test). Use [it](#it) to access [resource-specific matchers](#resource_specific_matcher), and use [its](#its) to access [properties](#property) of the [resource](#resource), which are in turn used with [universal matchers](#universal_matcher).
+
+With plural resources, `exist` has a special meaning: did the filter match anything?
+
+#### its('_manufacturers_') { should include 'Cadillac' }
+
+_manufacturers_ is a [property](#property) of the [resource](#resource). Properties expose testable information about the resource. On plural resources, properties are almost always names in the plural, and almost always return a list of values. Here, the test returns a list of the car manufacturer names. Some list properties are de-duplicated; for example, you might have 10 cars, but if they are all Subarus and Cadillacs, it returns only two entries in the `manufacturers` property. Be sure to check the documentation for your resource.
+
+#### its('manufacturers') { should _include_ 'Cadillac' }
+
+_include_ is a [universal matcher](#universal_matcher). `include` works with lists, and checks to see if an expected result is present. Here, it checks to see if the list of manufacturers contains an entry with the text 'Cadillac'. Notice it operates on the manufacturers list (the property value) and not on the resource. You can find the full list of supported universal matchers on the [Universal Matcher page](https://www.inspec.io/docs/reference/matchers/).
+
+#### its('manufacturers') { should include '_Cadillac_' }
+
+_'Cadillac'_ is an [expected result](#expected_result). Some matchers take an expected result; others do not.
+
+#### its('count') { should _be >=_ 10 }
+
+_be >=_ is an [operator matcher](#operator matcher). It allows you to perform numeric comparisons. All plural resources have a `count` property.
+
+## Text Glossary
+
+### attribute
+
+An _attribute_ is a parameter that InSpec reads from a YAML file provided on the command line. You can use this feature either to change a [profile's](#profile) behavior by passing different attribute files or to store secrets that should not be directly present in a profile. InSpec attributes are unrelated to Chef attributes.
+
+The CLI syntax for attributes is documented under the [`inspec exec`](https://www.inspec.io/docs/reference/cli/#exec) command.
+
+The syntax for accessing attributes within a profile is documented in the [profiles documentation](https://www.inspec.io/docs/reference/profiles/#profile-attributes).
+
+### control
+
+### control block
+
+The _`control`_ keyword is used to declare a _`control block`_. Here, the word 'control' means a 'regulatory control, recommendation, or requirement' - not a software engineering construct. A `control block` has a name (which usually refers to the assigned ID of the regulatory recommendation it implements), metadata such as descriptions, references, and tags, and finally groups together related [describe blocks](#describe_block) to implement the checks.
+
+### core resource
+
+A [resource](#resource) that is included with InSpec; you are not required to install additional [plugins](#plugin) or depend on a [resource pack](#resource pack) to use the resource.
+
+### custom resource
+
+A [resource](#resource) that is _not_ included with InSpec. It may be a resource of your own creation, or one you obtain by depending on a [resource pack](#resource pack).
+
+### describe
+
+### describe block
+
+The _`describe`_ keyword is used with a _`describe block`_ to refer to an InSpec resource. You use the `describe` keyword along with the name of a [resource](#resource) to enclose related [tests](#test) that apply to the resource. Multiple describe blocks are usually grouped together in a [control](#control), but you can also use them outside of a control.
+
+```
+control 'Rule 1.1 - Color restrictions' do
+  # Count only blue cars
+  describe cars.where(color: 'blue') do
+    its('count') { should eq 20 }
+  end
 end
 ```
-## Basic Elements:
 
-### describe **foo**, where
+### DSL
 
-  * `foo` is the _resource_
+_DSL_ is an acronym for _Domain Specific Language_. It refers to the language extensions InSpec provides to make authoring resources and controls easier. While InSpec control files are use Ruby, the _Control DSL_ makes it easy to write controls without knowledge of Ruby by providing DSL keywords such as [describe](#describe), [control](#control), [it](#it) and [its](#its). See the [InSpec DSL page](https://www.inspec.io/docs/reference/dsl_inspec/) for details about keywords available to control authors.
 
-### describe foo **('/path/to/foo.txt')**, where
+For [custom resource](#custom_resource) authors, an additional DSL is available - see the [Resource DSL page](https://www.inspec.io/docs/reference/dsl_resource/).
 
-  * `'/path/to/foo.txt'` is the _resource parameter_
+### expected result
 
-## Tests:
+When using a [matcher](#matcher), the _`expected result`_ is the value the matcher will compare against the [property](#property) being accessed.
 
-### **its('blah') { should cmp '123' }** is an _individual test_, where
+In this example, the [`cmp`](https://www.inspec.io/docs/reference/matchers/#cmp) matcher is being used to compare the `color` property to the expected result 'black'.
 
-  * `blah` is a _property_
-  * { should cmp '123' } is a _condition statement_
-  * `should`  is the _condition_
-  * `cmp`  is the _matcher_
-  * `'123'`  is the _expected result_
+```
+describe car(owner: 'Bruce Wayne') do
+  its('color') { should cmp 'black' }
+end
+```
 
-### **{ should exist }** is a _condition statement_, where
+### filter statement
 
-  * `should`  is the _condition_
-  * `exist`  is the _matcher_
+When using a [plural resource](#plural_resource), a _`filter statement`_ is used to select individual test subjects using [filter criteria](#filter_criteria). A filter statement almost always is indicated by the keyword `where`, and may be repeated using method chaining.
 
-### **{ should be\_reasonable }** is a _condition statement_, where
-    
-  * `should`  is the _condition_
-  * `be_reasonable`  is the _matcher_
+A filter statement may use method call syntax (which allows basic criteria operations, such as equality, regex matching, and ruby `===` comparison) or block syntax (which allows arbitrary code).
 
-### **{ should\_not be\_ridiculous }** is a _negative condition statement_, where
+In this example, `where(...)` is the filter statement.
 
-  * `should_not`  is the _negative condition_
-  * `be_ridiculous`  is the _matcher_
+```
+# Count only blue cars
+describe cars.where(color: 'blue') do
+  its('count') { should eq 20 }
+end
+```
+
+### filter criterion
+
+### filter criteria
+
+When using a [plural resource](#plural_resource), a _`filter criterion`_ is used to select individual test subjects within a [filter statement](#filter_statement). You may use multiple _`filter criteria`_ in a single filter statement.
+
+When method-call syntax is used with the filter statement, you provide filter criteria as a Hash, with filter criteria names as keys, and conditions as the Hash values. You may provide test, true/false, or numbers, in which case the comparison is equality; or you may provide a regular expression, in which case a match is performed.
 
-## Advanced Syntax
+Here, `(color: blue)` is a single filter criterion being used with a filter statement in method-call syntax.
 
 ```
-describe foos('/path/to/foo.txt', ssl_verify: true).where { names == 'blah' } do
-    its('jared') { should cmp >= 123 }
-    its('jared.sort.first.monkey') { should be `loud` }
-    its(['jared', 'monkey.with.dots']) { should be `loud` }
+# Count only blue cars
+describe cars.where(color: 'blue') do
+  its('count') { should eq 20 }
 end
 ```
 
-## Advanced Elements:
+When block-method syntax is used with the filter statement, you provide a block. The block may contain arbitrary code, and each filter criteria will be available as an accessor. The block will be evaluated once per row, and each block that evaluates to a truthy value will pass the filter.
 
-### describe **foos**, where
+Here, `{ engine_cylinders >= 6 }` is a block-syntax filter statement referring to one filter criterion.
 
-  * `foos` is a _plural resource_
+```
+# Vroom!
+describe cars.where { engine_cylinders >= 6 } do
+  its('city_mpg_ratings') { should_not include '4-star' }
+end
+```
 
-### describe foos **('/path/to/foo.txt', ssl_verify: true)**, where
+### it
 
-  * `'/path/to/foo.txt'` and `ssl_verify: true` are the _resource parameters_. Resources take one or more parameters.
+Within a [describe block](#describe), _`it`_ declares an individual [test](#test) directly against the [resource](#resource) (as opposed to testing against one of the resource's [properties](#property), as [its](#its) does). Though it is possible to use [universal matchers](#universal_matcher) with `it`, it is much more typical to use [resource-specific matchers](#resource_specific_matchers).
 
-## Filters:
+`it` may be used with `should`, or negated using `should_not`.
 
-### describe foos ('/path/to/foo.txt', ssl_verify: true)**.where { names == 'blah' }** 
+Here, `it { should ... }` declares a test, calling the `classy?` matcher on Tony Clifton's car.
 
-  * `.where  { names == 'blah' }` is an example of a **filter**. 
-  * `{ names == 'blah' }` is an example of a _filter clause_ 
-  * Some resources support one or more filters.
-  * Filters are used on plural resources. 
-  * Some resources, such as `etc_hosts` are explicitly plural, while others, such as `passwd` are implicitly plural. 
+```
+describe car(owner: 'Tony Clifton') do
+  it { should be_classy }
+end
+```
+
+### its
+
+Within a [describe block](#describe), _`its`_ declares an individual [test](#test) against a property of the [resource](#resource) (as opposed to testing directly against the resource itself, as [it](#it) does). You must use [universal matchers](#universal_matcher) with `its`; you cannot use [resource-specific matchers](#resource_specific_matchers).
+
+`its` may be used with `should`, or negated using `should_not`.
+
+The property to access is passed as a single string argument to `its`. As an advanced usage, if the property has methods you are interested in, you can call them using '`.`' within the string; even more advanced calling patterns are possible - see [the rspec-its documentation](https://github.com/rspec/rspec-its#usage).
+
+Here, `its('fuzzy_dice') { should ... }` declares a test, testing against the `fuzzy_dice` property of Tony Clifton's car. Let's assume - Tony being Tony - that `fuzzy_dice` will return an Array.
+
+```
+describe car(owner: 'Tony Clifton') do
+  its('fuzzy_dice') { should_not be_empty }
+  its('fuzzy_dice.count') { should be >= 2 }
+  its('fuzzy_dice.first.fuzziness') { should cmp 'outlandishly so' }
+end
+```
+
+### matcher
+
+A _`matcher`_ performs the actual assertions against [resources](#resource) or the [properties](#property) of resources. Matchers always return a true/false value. Matchers fall into two camps:
+
+* [resource-specific matchers](#resource_specific_matchers), which operate directly on the resource, are used with [it](#it), and tend to be highly customized to the auditing needs of the resource
+* [universal matchers](#universal_matchers), which operate on the properties of the resource, are used with [its](#its), and tend to be very generic, operating on text, numbers, and lists
+
+Some matchers accept parameters, called [expected results](#expected_results).
 
-### **{ names == 'my-name' && spots == true }** are filter criteria
+For information on how RSpec matchers are related o InSpec matchers, see [InSpec and RSpec](https://www.inspec.io/docs/reference/inspec_and_friends/#rspec).
+
+Here, `be_classy` is a resource-specific matcher operating directly on the `car`, while `cmp` is a universal matcher operating on the `manufacturer` property.
+
+```
+describe car(owner: 'Tony Clifton') do
+  it { should be_classy }
+  its('manufacturer') { should cmp 'Cadillac' }
+end
+```
 
-  * `names` compares output to `blah`
-  * `has spots` evaluates to `true` or `false`
+### plural resource
 
-## Properties:
+A _`plural resource`_ is a [resource](#resource) that specializes in performing searches and represents multiple occurrences of the resource on the [target](#target) platform. Plural resources are used to audit counts, inspect group properties, and have the unique ability to enforce negative tests ("nothing like this should exist") often required by compliance standards. Plural resources are not intended to perform in-depth auditing of an individual; use [singular resources](#singular_resource) for that.
 
-### **its('jared') { should cmp >= 123 }**
+Plural resources nearly always have a name that ends in 's': `processes`, `aws_security_groups`, `cars`. Plural resources generally do not have [resource-specific matchers](#resource_specific_matcher). If they have properties, they are almost always list properties, meaning that they return a list of values, which may or may not be de-duplicated.
 
-  * `jared` is the _property_
-  
-### **{ should cmp >= 123 }** is a conditional statement that uses a matcher with an operator and expected value.
+Plural resources support [filter statements](#filter_statement). See the [resource documentation](https://www.inspec.io/docs/reference/resources/) for details regarding which [filter criteria](#filter_criteria) are supported on each resource.
+
+Here, `cars` is a plural resource.
+
+```
+describe cars.where(color: 'blue') do
+  its('count') { should eq 20 }
+  its('license_plates') { should include 'AUTOAZUL' }
+
+  # License plates are unique, should have 20
+  its('license_plates.count') { should cmp 20 }
+
+  # Manufacturers are de-duplicated
+  its('manufacturers') { should include 'Subaru' }
+  its('manufacturers.count') { should be < 10 }
+end
+```
+
+### profile
+
+A _`profile`_ is a set of related [controls](#control) in a distributable form. You might have a locally-developed profile that your organization uses to define baseline security on all machines, or you might use a pre-defined profile that implements the requirements of a specific compliance standard. For full details about the capabilities of a profile, see the [profile documentation](https://www.inspec.io/docs/reference/profiles/).
+
+Profiles may be distributed locally as a directory tree, as a tarball or zipfile at a URL, as a git repo, and several other ways. Profiles contain metadata, including versioning, and can setup dependency relationships with other profiles.
+
+Aside from controls, profiles can also contain [custom resources](#custom_resource). If the profile contains only custom resources and no controls, we call it a [resource pack](#resource_pack).
+
+### property
+
+A fact about a [resource](#resource). Typically, you use the [its](#its) keyword to access the property and write a [test](#test) within a [describe block](#describe_block), and then use a [universal matcher](#universal_matcher) to make assertions about the value of the property.
+
+Each resource has different properties. See the [resource documentation](https://www.inspec.io/docs/reference/resources/) for details.
+
+Here, `manufacturer` is a property of the `car` resource.
+
+```
+describe car(owner: 'Tony Clifton') do
+  its('manufacturer') { should cmp 'Cadillac' }
+end
+```
 
-  * `cmp`  is the _matcher_
-  * `>=` is the operator (some matchers accept operators)
-  * `123` is the expected value
+### reporter
 
-## Properties with advanced usage:
+An output format for the `inspec exec` command line. Several reporters are available, including JSON and JUnit; see the [inspec exec documentation](https://www.inspec.io/docs/reference/cli/#exec).
 
-### Some properties may have advanced usage:
-#### **its `('jared.sort.first.monkey') { should be `loud` }`**
+### resource
 
-  * `jared.sort.first.monkey` is an example of the `jared` property with an advanced usage
+A _`resource`_ represents a category of things on the [target](#target) you wish to examine. For example, to check for the existence and permissions of a file, you would use the [`file`](https://www.inspec.io/docs/reference/resources/file/) resource. InSpec offers dozens of different resources, from the highly specialized (such as `aws_security_group`, which examines firewall rules in AWS) to the very general (such as `command`, which runs a command and lets you examine its output).
+
+Resources are generally categorized as either [singular](#singular_resource) or [plural](#plural_resource), though there are some irregular resources that cannot be cleanly considered one or the other.
+
+Resources are used within a [describe block](#describe_block) to perform [tests](#test).
+
+Here, `car` is a resource.
+
+```
+describe car(owner: 'Tony Clifton') do
+  it { should be_classy }
+end
+```
+
+### resource pack
+
+A _resource pack_ is a type of [profile](#profile) that is used to distribute [custom resources](#custom_resource). This specialized type of profile contains no [controls](#control), but it does contain a `libraries` directory within which Ruby files define custom resources.
+
+### resource parameter
+
+_`resource parameters`_ are information passed to the resource when they are declared. Typically, resource parameters provide identifying information or connectivity information. Resource parameters are not the same as a [filter statement](#filter_statement).
+
+Resource parameters vary from resource to resource; refer to the [resource documentation](https://www.inspec.io/docs/reference/resources/) for details.
+
+Here, `owner: 'Tony Clifton'` is a resource parameter.
+
+```
+describe car(owner: 'Tony Clifton') do
+  it { should be_classy }
+end
+```
+
+### resource-specific matcher
+
+A [matcher](#matcher) that operates directly on the [resource](#resource), as opposed to operating on a property as a [universal matcher](#universal matcher) does.
+
+Resource-specific matchers often provide highly customized behavior. Check the [resource documentation](#https://www.inspec.io/docs/reference/resources/) to discover which resource-specific matchers are available for your resource.
+
+For example, the hypothetical `car` resource defines a `classy?` method, which is exposed as the `be_classy` matcher in InSpec tests.
+
+```
+describe car(owner: 'Tony Clifton') do
+  it { should be_classy }
+end
+```
+
+### singular resource
+
+A [resource](#resource) intended to uniquely identify a single object on the [target](#target). Singular resources specialize in providing richer auditing capabilities via resource-specific matchers. Compare to [plural resources](#plural_resource).
+
+### target
+
+The _`target`_ is the OS or API on which InSpec is performing audits. In InSpec 1.x, this was always an operating system target (a bare metal machine, VM, or container). In InSpec 2.x and later, this can be an OS target, or an API target, including cloud providers such as AWS. InSpec is agentless, meaning that the InSpec code and profiles remain on your workstation, and the target is remotely interrogated without installing anything.
+
+### test
+
+A _`test`_ is an individual assertion about the state of the [resource](#resource) or one of its [properties](#property). All tests begin with the keyword [it](#it) or [its](#its). Tests are grouped within a [describe block](#describe_block).
+
+### universal matcher
+
+A _universal matcher_ is a [matcher](#matcher) that can be used on the [properties](#property) of any type of [resource](#resource). For example, you can use the `cmp` matcher to check the value of properties without having to worry about Ruby type-casting. Universal matchers are almost always used with the [its](#its) keyword.
+
+Universal matchers are documented on the [Universal Matchers](https://www.inspec.io/docs/reference/matchers/) page.
+
+Here, we access the 'color' property, then use the `cmp` universal matcher to compare the property to the 'black' [expected result](#expected_result).
+
+```
+describe car(owner: 'Bruce Wayne') do
+  its('color') { should cmp 'black' }
+end
+```

data/lib/inspec/rule.rb

@@ -193,7 +193,7 @@ module Inspec
       [['describe', [resource], nil]]
     end
 
-    def self.merge(dst, src)
+    def self.merge(dst, src) # rubocop:disable Metrics/AbcSize
       if src.id != dst.id
         # TODO: register an error, this case should not happen
         return
@@ -208,6 +208,15 @@ module Inspec
       dst.impact(src.impact) unless src.impact.nil?
       dst.title(src.title)   unless src.title.nil?
       dst.desc(src.desc)     unless src.desc.nil?
+      dst.tag(src.tag)       unless src.tag.nil?
+      dst.ref(src.ref)       unless src.ref.nil?
+
+      # use the most recent source location
+      dst.instance_variable_set(
+        :@__source_location,
+        src.instance_variable_get(:@__source_location),
+      )
+
       # merge indirect fields
       # checks defined in the source will completely eliminate
       # all checks that were defined in the destination

data/lib/inspec/version.rb

@@ -4,5 +4,5 @@
 # author: Christoph Hartmann
 
 module Inspec
-  VERSION = '2.2.16'
+  VERSION = '2.2.20'
 end

data/lib/resources/auditd.rb

@@ -30,11 +30,26 @@ module Inspec::Resources
     "
 
     def initialize
-      @content = inspec.command('/sbin/auditctl -l').stdout.chomp
+      unless inspec.command('/sbin/auditctl').exist?
+        raise Inspec::Exceptions::ResourceFailed,
+              'Command `/sbin/auditctl` does not exist'
+      end
+
+      auditctl_cmd = '/sbin/auditctl -l'
+      result = inspec.command(auditctl_cmd)
+
+      if result.exit_status != 0
+        raise Inspec::Exceptions::ResourceFailed,
+              "Command `#{auditctl_cmd}` failed with error: #{result.stderr}"
+      end
+
+      @content = result.stdout
       @params = []
 
       if @content =~ /^LIST_RULES:/
-        return skip_resource 'The version of audit is outdated. The `auditd` resource supports versions of audit >= 2.3.'
+        raise Inspec::Exceptions::RsourceFailed,
+              'The version of audit is outdated.' \
+              'The `auditd` resource supports versions of audit >= 2.3.'
       end
       parse_content
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: inspec-core
 version: !ruby/object:Gem::Version
-  version: 2.2.16
+  version: 2.2.20
 platform: ruby
 authors:
 - Dominik Richter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-15 00:00:00.000000000 Z
+date: 2018-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: train-core