diff --git a/CHANGELOG.md b/CHANGELOG.md
index f889866..54367be 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,204 +1,204 @@
 ##2014-09-10 - Supported Release 1.1.1
 
 ###Summary
 
 This is a bugfix release, and the first supported release of the 1.1.x series.
 
 ####Bugfixes
 - Make the `$order` parameter default to a string and be validated as an integer
   or a string
 - Use the ruby script on Solaris to not break Sol10 support
-- Add quotes to the ryby script location for Windows
+- Add quotes to the ruby script location for Windows
 - Fix typos in README.md
 - Make regex in concat::setup case-insensitive to make it work on Windows
 - Make sure concat fragments are always replaced
 - Fix validation to allow `$backup` to be a boolean
 - Remove dependency on stdlib 4.x
 - Fix for lack of idempotency with `ensure => 'absent'`
 - Fix tests and spec_helper
 - Synchronized files for more consistency across modules via modulesync
 
 ##2014-05-14 - Release 1.1.0
 
 ###Summary
 
 This release is primarily a bugfix release since 1.1.0-rc1.
 
 ####Features
 - Improved testing, with tests moved to beaker
 
 ####Bugfixes
 - No longer attempts to set fragment owner and mode on Windows
 - Fix numeric sorting
 - Fix incorrect quoting
 - Fix newlines
 
 ##2014-01-03 - Release 1.1.0-rc1
 
 ###Summary
 
 This release of concat was 90% written by Joshua Hoblitt, and the module team
 would like to thank him for the huge amount of work he put into this release.
 
 This module deprecates a bunch of old parameters and usage patterns, modernizes
 much of the manifest code, simplifies a whole bunch of logic and makes
 improvements to almost all parts of the module.
 
 The other major feature is windows support, courtesy of luisfdez, with an
 alternative version of the concat bash script in ruby.  We've attempted to
 ensure that there are no backwards incompatible changes, all users of 1.0.0
 should be able to use 1.1.0 without any failures, but you may find deprecation
 warnings and we'll be aggressively moving for a 2.0 to remove those too.
 
 For further information on deprecations, please read:
 https://github.com/puppetlabs/puppetlabs-concat/blob/master/README.md#api-deprecations
 
 ####Removed
 - Puppet 0.24 support.
 - Filebucket backup of all file resources except the target concatenated file.
 - Default owner/user/group values.
 - Purging of long unused /usr/local/bin/concatfragments.sh
 
 ###Features
 - Windows support via a ruby version of the concat bash script.
 - Huge amount of acceptance testing work added.
 - Documentation (README) completely rewritten.
 - New parameters in concat:
  - `ensure`: Controls if the file should be present/absent at all.
  - Remove requirement to include concat::setup in manifests.
  - Made `gnu` parameter deprecated.
  - Added parameter validation.
 
 ###Bugfixes
  - Ensure concat::setup runs before concat::fragment in all cases.
  - Pluginsync references updated for modern Puppet.
  - Fix incorrect group parameter.
  - Use $owner instead of $id to avoid confusion with $::id
  - Compatibility fixes for Puppet 2.7/ruby 1.8.7
  - Use LC_ALL=C instead of LANG=C
  - Always exec the concatfragments script as root when running as root.
  - Syntax and other cleanup changes.
 
 ##2014-06-25 - Supported Release 1.0.4
 ###Summary
 
 This release has test fixes.
 
 ####Features
 - Added test support for OSX.
 
 ####Bugfixes
 
 ####Known bugs
 
 * Not supported on Windows.
 
 ##2014-06-04 - Release 1.0.3
 ###Summary
 
 This release adds compatibility for PE3.3 and fixes tests.
 
 ####Features
 - Added test support for Ubuntu Trusty.
 
 ####Bugfixes
 
 ####Known bugs
 
 *Not supported on Windows.
 
 ##2014-03-04 - Supported Release 1.0.2
 ###Summary
 
 This is a supported release. No functional changes were made from 1.0.1.
 
 ####Features
 - Huge amount of tests backported from 1.1.
 - Documentation rewrite.
 
 ####Bugfixes
 
 ####Known Bugs
 
 * Not supported on Windows.
 
 
 ##2014-02-12 - 1.0.1
 
 ###Summary
 
 Minor bugfixes for sorting of fragments and ordering of resources.
 
 ####Bugfixes
 - LANG => C replaced with LC_ALL => C to reduce spurious recreation of
 fragments.
 - Corrected pluginsync documentation.
 - Ensure concat::setup always runs before fragments.
 
 
 ##2013-08-09 - 1.0.0
 
 ###Summary
 
 Many new features and bugfixes in this release, and if you're a heavy concat
 user you should test carefully before upgrading.  The features should all be
 backwards compatible but only light testing has been done from our side before
 this release.
 
 ####Features
 - New parameters in concat:
  - `replace`: specify if concat should replace existing files.
  - `ensure_newline`: controls if fragments should contain a newline at the end.
 - Improved README documentation.
 - Add rspec:system tests (rake spec:system to test concat)
 
 ####Bugfixes
 - Gracefully handle \n in a fragment resource name.
 - Adding more helpful message for 'pluginsync = true'
 - Allow passing `source` and `content` directly to file resource, rather than
 defining resource defaults.
 - Added -r flag to read so that filenames with \ will be read correctly.
 - sort always uses LANG=C.
 - Allow WARNMSG to contain/start with '#'.
 - Replace while-read pattern with for-do in order to support Solaris.
 
 ####CHANGELOG:
 - 2010/02/19 - initial release
 - 2010/03/12 - add support for 0.24.8 and newer
              - make the location of sort configurable
              - add the ability to add shell comment based warnings to
                top of files
              - add the ablity to create empty files
 - 2010/04/05 - fix parsing of WARN and change code style to match rest
                of the code
              - Better and safer boolean handling for warn and force
              - Don't use hard coded paths in the shell script, set PATH
                top of the script
              - Use file{} to copy the result and make all fragments owned
                by root.  This means we can chnage the ownership/group of the
                resulting file at any time.
              - You can specify ensure => "/some/other/file" in concat::fragment
                to include the contents of a symlink into the final file.
 - 2010/04/16 - Add more cleaning of the fragment name - removing / from the $name
 - 2010/05/22 - Improve documentation and show the use of ensure =>
 - 2010/07/14 - Add support for setting the filebucket behavior of files
 - 2010/10/04 - Make the warning message configurable
 - 2010/12/03 - Add flags to make concat work better on Solaris - thanks Jonathan Boyett
 - 2011/02/03 - Make the shell script more portable and add a config option for root group
 - 2011/06/21 - Make base dir root readable only for security
 - 2011/06/23 - Set base directory using a fact instead of hardcoding it
 - 2011/06/23 - Support operating as non privileged user
 - 2011/06/23 - Support dash instead of bash or sh
 - 2011/07/11 - Better solaris support
 - 2011/12/05 - Use fully qualified variables
 - 2011/12/13 - Improve Nexenta support
 - 2012/04/11 - Do not use any GNU specific extensions in the shell script
 - 2012/03/24 - Comply to community style guides
 - 2012/05/23 - Better errors when basedir isnt set
 - 2012/05/31 - Add spec tests
 - 2012/07/11 - Include concat::setup in concat improving UX
 - 2012/08/14 - Puppet Lint improvements
 - 2012/08/30 - The target path can be different from the $name
 - 2012/08/30 - More Puppet Lint cleanup
 - 2012/09/04 - RELEASE 0.2.0
 - 2012/12/12 - Added (file) $replace parameter to concat
diff --git a/metadata.json b/metadata.json
index 51f42f9..5a48a8f 100644
--- a/metadata.json
+++ b/metadata.json
@@ -1,111 +1,113 @@
 {
   "name": "puppetlabs-concat",
   "version": "1.1.1",
   "author": "Puppet Labs",
   "summary": "Concat module",
   "license": "Apache-2.0",
   "source": "https://github.com/puppetlabs/puppetlabs-concat",
   "project_page": "https://github.com/puppetlabs/puppetlabs-concat",
   "issues_url": "https://github.com/puppetlabs/puppetlabs-concat/issues",
   "operatingsystem_support": [
     {
       "operatingsystem": "RedHat",
       "operatingsystemrelease": [
         "5",
         "6",
         "7"
       ]
     },
     {
       "operatingsystem": "CentOS",
       "operatingsystemrelease": [
         "5",
         "6",
         "7"
       ]
     },
     {
       "operatingsystem": "OracleLinux",
       "operatingsystemrelease": [
         "5",
         "6",
         "7"
       ]
     },
     {
       "operatingsystem": "Scientific",
       "operatingsystemrelease": [
         "5",
         "6",
         "7"
       ]
     },
     {
       "operatingsystem": "SLES",
       "operatingsystemrelease": [
-        "11 SP1"
+        "10 SP4",
+        "11 SP1",
+        "12"
       ]
     },
     {
       "operatingsystem": "Debian",
       "operatingsystemrelease": [
         "6",
         "7"
       ]
     },
     {
       "operatingsystem": "Ubuntu",
       "operatingsystemrelease": [
         "10.04",
         "12.04",
         "14.04"
       ]
     },
     {
       "operatingsystem": "Solaris",
       "operatingsystemrelease": [
         "10",
         "11"
       ]
     },
     {
       "operatingsystem": "Windows",
       "operatingsystemrelease": [
         "Server 2003 R2",
         "Server 2008 R2",
         "Server 2012",
         "Server 2012 R2"
       ]
     },
     {
       "operatingsystem": "AIX",
       "operatingsystemrelease": [
         "5.3",
         "6.1",
         "7.1"
       ]
     },
     {
       "operatingsystem": "OSX",
       "operatingsystemrelease": [
         "10.9"
       ]
     }
   ],
   "requirements": [
     {
       "name": "pe",
       "version_requirement": "3.x"
     },
     {
       "name": "puppet",
       "version_requirement": "3.x"
     }
   ],
   "dependencies": [
     {
       "name": "puppetlabs/stdlib",
       "version_requirement": ">= 3.2.0 < 5.0.0"
     }
   ]
 }
diff --git a/spec/acceptance/concat_spec.rb b/spec/acceptance/concat_spec.rb
index 10f72d9..7cec1a5 100644
--- a/spec/acceptance/concat_spec.rb
+++ b/spec/acceptance/concat_spec.rb
@@ -1,215 +1,215 @@
 require 'spec_helper_acceptance'
 
 case fact('osfamily')
 when 'AIX'
   username   = 'root'
   groupname  = 'system'
   scriptname = 'concatfragments.sh'
   vardir     = default['puppetvardir']
 when 'Darwin'
   username   = 'root'
   groupname  = 'wheel'
   scriptname = 'concatfragments.sh'
   vardir     = default['puppetvardir']
 when 'windows'
   username   = 'Administrator'
   groupname  = 'Administrators'
   scriptname = 'concatfragments.rb'
   result     = on default, "echo #{default['puppetvardir']}"
   vardir     = result.raw_output.chomp
 when 'Solaris'
   username   = 'root'
   groupname  = 'root'
   scriptname = 'concatfragments.rb'
   vardir     = default['puppetvardir']
 else
   username   = 'root'
   groupname  = 'root'
   scriptname = 'concatfragments.sh'
   vardir     = default['puppetvardir']
 end
 
 describe 'basic concat test' do
   basedir = default.tmpdir('concat')
   safe_basedir = basedir.gsub(/[\/:]/,'_')
 
   shared_examples 'successfully_applied' do |pp|
     it 'applies the manifest twice with no stderr' do
       apply_manifest(pp, :catch_failures => true)
       apply_manifest(pp, :catch_changes => true)
     end
 
     describe file("#{vardir}/concat") do
       it { should be_directory }
       it { should be_owned_by username }
-      it("should be mode", :unless => (fact('osfamily') == 'AIX')) {
+      it("should be mode", :unless => (fact('osfamily') == 'AIX' or fact('osfamily') == 'windows')) {
         should be_mode 755
       }
     end
      describe file("#{vardir}/concat/bin") do
       it { should be_directory }
       it { should be_owned_by username }
-      it("should be mode", :unless => (fact('osfamily') == 'AIX')) {
+      it("should be mode", :unless => (fact('osfamily') == 'AIX' or fact('osfamily') == 'windows')) {
         should be_mode 755
       }
     end
     describe file("#{vardir}/concat/bin/#{scriptname}") do
       it { should be_file }
       it { should be_owned_by username }
-      it("should be mode", :unless => (fact('osfamily') == 'AIX')) {
+      it("should be mode", :unless => (fact('osfamily') == 'AIX' or fact('osfamily') == 'windows')) {
         should be_mode 755
       }
     end
     describe file("#{vardir}/concat/#{safe_basedir}_file") do
       it { should be_directory }
       it { should be_owned_by username }
-      it("should be mode", :unless => (fact('osfamily') == 'AIX')) {
+      it("should be mode", :unless => (fact('osfamily') == 'AIX' or fact('osfamily') == 'windows')) {
         should be_mode 750
       }
     end
     describe file("#{vardir}/concat/#{safe_basedir}_file/fragments") do
       it { should be_directory }
       it { should be_owned_by username }
-      it("should be mode", :unless => (fact('osfamily') == 'AIX')) {
+      it("should be mode", :unless => (fact('osfamily') == 'AIX' or fact('osfamily') == 'windows')) {
         should be_mode 750
       }
     end
     describe file("#{vardir}/concat/#{safe_basedir}_file/fragments.concat") do
       it { should be_file }
       it { should be_owned_by username }
-      it("should be mode", :unless => (fact('osfamily') == 'AIX')) {
+      it("should be mode", :unless => (fact('osfamily') == 'AIX' or fact('osfamily') == 'windows')) {
         should be_mode 640
       }
     end
     describe file("#{vardir}/concat/#{safe_basedir}_file/fragments.concat.out") do
       it { should be_file }
       it { should be_owned_by username }
-      it("should be mode", :unless => (fact('osfamily') == 'AIX')) {
+      it("should be mode", :unless => (fact('osfamily') == 'AIX' or fact('osfamily') == 'windows')) {
         should be_mode 640
       }
     end
   end
 
   context 'owner/group root' do
     before(:all) do
       pp = <<-EOS
         file { '#{basedir}':
           ensure => directory,
         }
       EOS
       apply_manifest(pp)
     end
     pp = <<-EOS
       concat { '#{basedir}/file':
         owner => '#{username}',
         group => '#{groupname}',
         mode  => '0644',
       }
 
       concat::fragment { '1':
         target  => '#{basedir}/file',
         content => '1',
         order   => '01',
       }
 
       concat::fragment { '2':
         target  => '#{basedir}/file',
         content => '2',
         order   => '02',
       }
     EOS
 
     it_behaves_like 'successfully_applied', pp
 
     describe file("#{basedir}/file") do
       it { should be_file }
       it { should be_owned_by username }
-      it { should be_grouped_into groupname }
-      it("should be mode", :unless => (fact('osfamily') == 'AIX')) {
+      it("should be group", :unless => (fact('osfamily') == 'windows')) { should be_grouped_into groupname }
+      it("should be mode", :unless => (fact('osfamily') == 'AIX' or fact('osfamily') == 'windows')) {
         should be_mode 644
       }
       it { should contain '1' }
       it { should contain '2' }
     end
     describe file("#{vardir}/concat/#{safe_basedir}_file/fragments/01_1") do
       it { should be_file }
       it { should be_owned_by username }
-      it("should be mode", :unless => (fact('osfamily') == 'AIX')) {
+      it("should be mode", :unless => (fact('osfamily') == 'AIX' or fact('osfamily') == 'windows')) {
         should be_mode 640
       }
     end
     describe file("#{vardir}/concat/#{safe_basedir}_file/fragments/02_2") do
       it { should be_file }
       it { should be_owned_by username }
-      it("should be mode", :unless => (fact('osfamily') == 'AIX')) {
+      it("should be mode", :unless => (fact('osfamily') == 'AIX' or fact('osfamily') == 'windows')) {
         should be_mode 640
       }
     end
   end
 
   context 'ensure' do
     context 'works when set to present with path set' do
       before(:all) do
         pp = <<-EOS
         file { '#{basedir}':
           ensure => directory,
         }
         EOS
         apply_manifest(pp)
       end
       pp="
         concat { 'file':
           ensure => present,
           path   => '#{basedir}/file',
           mode   => '0644',
         }
         concat::fragment { '1':
           target  => 'file',
           content => '1',
           order   => '01',
         }
       "
 
       it_behaves_like 'successfully_applied', pp
 
       describe file("#{basedir}/file") do
         it { should be_file }
-        it("should be mode", :unless => (fact('osfamily') == 'AIX')) {
+        it("should be mode", :unless => (fact('osfamily') == 'AIX' or fact('osfamily') == 'windows')) {
           should be_mode 644
         }
         it { should contain '1' }
       end
     end
     context 'works when set to absent with path set' do
       before(:all) do
         pp = <<-EOS
         file { '#{basedir}':
           ensure => directory,
         }
         EOS
         apply_manifest(pp)
       end
       pp="
         concat { 'file':
           ensure => absent,
           path   => '#{basedir}/file',
           mode   => '0644',
         }
         concat::fragment { '1':
           target  => 'file',
           content => '1',
           order   => '01',
         }
       "
 
       it 'applies the manifest twice with no stderr' do
         apply_manifest(pp, :catch_failures => true)
         apply_manifest(pp, :catch_changes => true)
       end
 
       describe file("#{basedir}/file") do
         it { should_not be_file }
       end
     end
   end
 end
diff --git a/spec/acceptance/deprecation_warnings_spec.rb b/spec/acceptance/deprecation_warnings_spec.rb
index 7b0f5c5..dc2f234 100644
--- a/spec/acceptance/deprecation_warnings_spec.rb
+++ b/spec/acceptance/deprecation_warnings_spec.rb
@@ -1,233 +1,232 @@
 require 'spec_helper_acceptance'
 
 describe 'deprecation warnings' do
   basedir = default.tmpdir('concat')
 
   shared_examples 'has_warning'do |pp, w|
     it 'applies the manifest twice with a stderr regex' do
       expect(apply_manifest(pp, :catch_failures => true).stderr).to match(/#{Regexp.escape(w)}/m)
       expect(apply_manifest(pp, :catch_changes => true).stderr).to match(/#{Regexp.escape(w)}/m)
     end
   end
 
   context 'concat gnu parameter' do
     pp = <<-EOS
       concat { '#{basedir}/file':
         gnu => 'foo',
       }
       concat::fragment { 'foo':
         target  => '#{basedir}/file',
         content => 'bar',
       }
     EOS
     w = 'The $gnu parameter to concat is deprecated and has no effect'
 
     it_behaves_like 'has_warning', pp, w
   end
 
   context 'concat warn parameter =>' do
     ['true', 'yes', 'on'].each do |warn|
       context warn do
         pp = <<-EOS
           concat { '#{basedir}/file':
             warn => '#{warn}',
           }
           concat::fragment { 'foo':
             target  => '#{basedir}/file',
             content => 'bar',
           }
         EOS
         w = 'Using stringified boolean values (\'true\', \'yes\', \'on\', \'false\', \'no\', \'off\') to represent boolean true/false as the $warn parameter to concat is deprecated and will be treated as the warning message in a future release'
 
         it_behaves_like 'has_warning', pp, w
 
         describe file("#{basedir}/file") do
           it { should be_file }
           it { should contain '# This file is managed by Puppet. DO NOT EDIT.' }
           it { should contain 'bar' }
         end
       end
     end
 
     ['false', 'no', 'off'].each do |warn|
       context warn do
         pp = <<-EOS
           concat { '#{basedir}/file':
             warn => '#{warn}',
           }
           concat::fragment { 'foo':
             target  => '#{basedir}/file',
             content => 'bar',
           }
         EOS
         w = 'Using stringified boolean values (\'true\', \'yes\', \'on\', \'false\', \'no\', \'off\') to represent boolean true/false as the $warn parameter to concat is deprecated and will be treated as the warning message in a future release'
 
         it_behaves_like 'has_warning', pp, w
 
         describe file("#{basedir}/file") do
           it { should be_file }
           it { should_not contain '# This file is managed by Puppet. DO NOT EDIT.' }
           it { should contain 'bar' }
         end
       end
     end
   end
 
-  context 'concat::fragment ensure parameter' do
+  context 'concat::fragment ensure parameter', :unless => fact('osfamily') == 'windows' do
     context 'target file exists' do
       before(:all) do
-        shell("/bin/echo 'file1 contents' > #{basedir}/file1")
         pp = <<-EOS
           file { '#{basedir}':
             ensure => directory,
           }
           file { '#{basedir}/file1':
             content => "file1 contents\n",
           }
         EOS
         apply_manifest(pp)
       end
 
       pp = <<-EOS
         concat { '#{basedir}/file': }
         concat::fragment { 'foo':
           target => '#{basedir}/file',
           ensure => '#{basedir}/file1',
         }
       EOS
       w = 'Passing a value other than \'present\' or \'absent\' as the $ensure parameter to concat::fragment is deprecated.  If you want to use the content of a file as a fragment please use the $source parameter.'
 
       it_behaves_like 'has_warning', pp, w
 
       describe file("#{basedir}/file") do
         it { should be_file }
         it { should contain 'file1 contents' }
       end
 
       describe 'the fragment can be changed from a symlink to a plain file', :unless => (fact("osfamily") == "windows") do
         pp = <<-EOS
           concat { '#{basedir}/file': }
           concat::fragment { 'foo':
             target  => '#{basedir}/file',
             content => 'new content',
           }
         EOS
 
         it 'applies the manifest twice with no stderr' do
           apply_manifest(pp, :catch_failures => true)
           apply_manifest(pp, :catch_changes => true)
         end
 
         describe file("#{basedir}/file") do
           it { should be_file }
           it { should contain 'new content' }
           it { should_not contain 'file1 contents' }
         end
       end
     end # target file exists
 
-    context 'target does not exist' do
+    context 'target does not exist', :unless => fact('osfamily') == 'windows' do
       pp = <<-EOS
         concat { '#{basedir}/file': }
         concat::fragment { 'foo':
           target => '#{basedir}/file',
           ensure => '#{basedir}/file1',
         }
       EOS
       w = 'Passing a value other than \'present\' or \'absent\' as the $ensure parameter to concat::fragment is deprecated.  If you want to use the content of a file as a fragment please use the $source parameter.'
 
       it_behaves_like 'has_warning', pp, w
 
       describe file("#{basedir}/file") do
         it { should be_file }
       end
 
       describe 'the fragment can be changed from a symlink to a plain file', :unless => (fact('osfamily') == 'windows') do
         pp = <<-EOS
           concat { '#{basedir}/file': }
           concat::fragment { 'foo':
             target  => '#{basedir}/file',
             content => 'new content',
           }
         EOS
 
         it 'applies the manifest twice with no stderr' do
           apply_manifest(pp, :catch_failures => true)
           apply_manifest(pp, :catch_changes => true)
         end
 
         describe file("#{basedir}/file") do
           it { should be_file }
           it { should contain 'new content' }
         end
       end
     end # target file exists
 
   end # concat::fragment ensure parameter
 
   context 'concat::fragment mode parameter' do
     pp = <<-EOS
       concat { '#{basedir}/file': }
       concat::fragment { 'foo':
         target  => '#{basedir}/file',
         content => 'bar',
         mode    => 'bar',
       }
     EOS
     w = 'The $mode parameter to concat::fragment is deprecated and has no effect'
 
     it_behaves_like 'has_warning', pp, w
   end
 
   context 'concat::fragment owner parameter' do
     pp = <<-EOS
       concat { '#{basedir}/file': }
       concat::fragment { 'foo':
         target  => '#{basedir}/file',
         content => 'bar',
         owner   => 'bar',
       }
     EOS
     w = 'The $owner parameter to concat::fragment is deprecated and has no effect'
 
     it_behaves_like 'has_warning', pp, w
   end
 
   context 'concat::fragment group parameter' do
     pp = <<-EOS
       concat { '#{basedir}/file': }
       concat::fragment { 'foo':
         target  => '#{basedir}/file',
         content => 'bar',
         group   => 'bar',
       }
     EOS
     w = 'The $group parameter to concat::fragment is deprecated and has no effect'
 
     it_behaves_like 'has_warning', pp, w
   end
 
   context 'concat::fragment backup parameter' do
     pp = <<-EOS
       concat { '#{basedir}/file': }
       concat::fragment { 'foo':
         target  => '#{basedir}/file',
         content => 'bar',
         backup  => 'bar',
       }
     EOS
     w = 'The $backup parameter to concat::fragment is deprecated and has no effect'
 
     it_behaves_like 'has_warning', pp, w
   end
 
   context 'include concat::setup' do
     pp = <<-EOS
       include concat::setup
     EOS
     w = 'concat::setup is deprecated as a public API of the concat module and should no longer be directly included in the manifest.'
 
     it_behaves_like 'has_warning', pp, w
   end
 
 end
diff --git a/spec/acceptance/replace_spec.rb b/spec/acceptance/replace_spec.rb
index cc30d12..6882345 100644
--- a/spec/acceptance/replace_spec.rb
+++ b/spec/acceptance/replace_spec.rb
@@ -1,256 +1,256 @@
 require 'spec_helper_acceptance'
 
 describe 'replacement of' do
   basedir = default.tmpdir('concat')
   context 'file' do
     context 'should not succeed' do
       before(:all) do
         pp = <<-EOS
           file { '#{basedir}':
             ensure => directory,
           }
           file { '#{basedir}/file':
             content => "file exists\n"
           }
         EOS
         apply_manifest(pp)
       end
       pp = <<-EOS
         concat { '#{basedir}/file':
           replace => false,
         }
 
         concat::fragment { '1':
           target  => '#{basedir}/file',
           content => '1',
         }
 
         concat::fragment { '2':
           target  => '#{basedir}/file',
           content => '2',
         }
       EOS
 
       it 'applies the manifest twice with no stderr' do
         apply_manifest(pp, :catch_failures => true)
         apply_manifest(pp, :catch_changes => true)
       end
 
       describe file("#{basedir}/file") do
         it { should be_file }
         it { should contain 'file exists' }
         it { should_not contain '1' }
         it { should_not contain '2' }
       end
     end
 
     context 'should succeed' do
       before(:all) do
         pp = <<-EOS
           file { '#{basedir}':
             ensure => directory,
           }
           file { '#{basedir}/file':
             content => "file exists\n"
           }
         EOS
         apply_manifest(pp)
       end
       pp = <<-EOS
         concat { '#{basedir}/file':
           replace => true,
         }
 
         concat::fragment { '1':
           target  => '#{basedir}/file',
           content => '1',
         }
 
         concat::fragment { '2':
           target  => '#{basedir}/file',
           content => '2',
         }
       EOS
 
       it 'applies the manifest twice with no stderr' do
         apply_manifest(pp, :catch_failures => true)
         apply_manifest(pp, :catch_changes => true)
       end
 
       describe file("#{basedir}/file") do
         it { should be_file }
         it { should_not contain 'file exists' }
         it { should contain '1' }
         it { should contain '2' }
       end
     end
   end # file
 
   context 'symlink', :unless => (fact("osfamily") == "windows") do
     context 'should not succeed' do
       # XXX the core puppet file type will replace a symlink with a plain file
       # when using ensure => present and source => ... but it will not when using
       # ensure => present and content => ...; this is somewhat confusing behavior
       before(:all) do
         pp = <<-EOS
           file { '#{basedir}':
             ensure => directory,
           }
           file { '#{basedir}/file':
             ensure => link,
             target => '#{basedir}/dangling',
           }
         EOS
         apply_manifest(pp)
       end
 
       pp = <<-EOS
         concat { '#{basedir}/file':
           replace => false,
         }
 
         concat::fragment { '1':
           target  => '#{basedir}/file',
           content => '1',
         }
 
         concat::fragment { '2':
           target  => '#{basedir}/file',
           content => '2',
         }
       EOS
 
       it 'applies the manifest twice with no stderr' do
         apply_manifest(pp, :catch_failures => true)
         apply_manifest(pp, :catch_changes => true)
       end
 
       # XXX specinfra doesn't support be_linked_to on AIX
-      describe file("#{basedir}/file"), :unless => (fact("osfamily") == "AIX") do
+      describe file("#{basedir}/file"), :unless => (fact("osfamily") == "AIX" or fact("osfamily") == "windows") do
         it { should be_linked_to "#{basedir}/dangling" }
       end
 
       describe file("#{basedir}/dangling") do
         # XXX serverspec does not have a matcher for 'exists'
         it { should_not be_file }
         it { should_not be_directory }
       end
     end
 
     context 'should succeed' do
       # XXX the core puppet file type will replace a symlink with a plain file
       # when using ensure => present and source => ... but it will not when using
       # ensure => present and content => ...; this is somewhat confusing behavior
       before(:all) do
         pp = <<-EOS
           file { '#{basedir}':
             ensure => directory,
           }
           file { '#{basedir}/file':
             ensure => link,
             target => '#{basedir}/dangling',
           }
         EOS
         apply_manifest(pp)
       end
 
       pp = <<-EOS
         concat { '#{basedir}/file':
           replace => true,
         }
 
         concat::fragment { '1':
           target  => '#{basedir}/file',
           content => '1',
         }
 
         concat::fragment { '2':
           target  => '#{basedir}/file',
           content => '2',
         }
       EOS
 
       it 'applies the manifest twice with no stderr' do
         apply_manifest(pp, :catch_failures => true)
         apply_manifest(pp, :catch_changes => true)
       end
 
       describe file("#{basedir}/file") do
         it { should be_file }
         it { should contain '1' }
         it { should contain '2' }
       end
     end
   end # symlink
 
   context 'directory' do
     context 'should not succeed' do
       before(:all) do
         pp = <<-EOS
           file { '#{basedir}':
             ensure => directory,
           }
           file { '#{basedir}/file':
             ensure => directory,
           }
         EOS
         apply_manifest(pp)
       end
       pp = <<-EOS
         concat { '#{basedir}/file': }
 
         concat::fragment { '1':
           target  => '#{basedir}/file',
           content => '1',
         }
 
         concat::fragment { '2':
           target  => '#{basedir}/file',
           content => '2',
         }
       EOS
 
       it 'applies the manifest twice with stderr for changing to file' do
         expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/change from directory to file failed/)
         expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/change from directory to file failed/)
       end
 
       describe file("#{basedir}/file") do
         it { should be_directory }
       end
     end
 
     # XXX concat's force param currently enables the creation of empty files
     # when there are no fragments, and the replace param will only replace
     # files and symlinks, not directories.  The semantics either need to be
     # changed, extended, or a new param introduced to control directory
     # replacement.
     context 'should succeed', :pending => 'not yet implemented' do
       pp = <<-EOS
         concat { '#{basedir}/file':
           force => true,
         }
 
         concat::fragment { '1':
           target  => '#{basedir}/file',
           content => '1',
         }
 
         concat::fragment { '2':
           target  => '#{basedir}/file',
           content => '2',
         }
       EOS
 
       it 'applies the manifest twice with no stderr' do
         apply_manifest(pp, :catch_failures => true)
         apply_manifest(pp, :catch_changes => true)
       end
 
       describe file("#{basedir}/file") do
         it { should be_file }
         it { should contain '1' }
       end
     end
   end # directory
 end
diff --git a/spec/spec_helper_acceptance.rb b/spec/spec_helper_acceptance.rb
index b34a188..713466e 100644
--- a/spec/spec_helper_acceptance.rb
+++ b/spec/spec_helper_acceptance.rb
@@ -1,47 +1,51 @@
 require 'beaker-rspec/spec_helper'
 require 'beaker-rspec/helpers/serverspec'
 
 unless ENV['RS_PROVISION'] == 'no' or ENV['BEAKER_provision'] == 'no'
   # This will install the latest available package on el and deb based
   # systems fail on windows and osx, and install via gem on other *nixes
   foss_opts = { :default_action => 'gem_install' }
 
   if default.is_pe?; then install_pe; else install_puppet( foss_opts ); end
 
   hosts.each do |host|
     on hosts, "mkdir -p #{host['distmoduledir']}"
   end
 end
 
 RSpec.configure do |c|
   # Project root
   proj_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
 
   # Readable test descriptions
   c.formatter = :documentation
 
   # Configure all nodes in nodeset
   c.before :suite do
     # Install module and dependencies
     hosts.each do |host|
+      if fact_on(host, 'osfamily') == 'windows'
+        on host, 'powershell.exe -command "(New-Object System.Net.Webclient).DownloadString(\'https://forge.puppetlabs.com\')"'
+      end
+
       on host, "mkdir -p #{host['distmoduledir']}/concat"
       result = on host, "echo #{host['distmoduledir']}/concat"
       target = result.raw_output.chomp
 
       %w(files lib manifests metadata.json).each do |file|
         scp_to host, "#{proj_root}/#{file}", target
       end
       #copy_module_to(host, :source => proj_root, :module_name => 'concat')
       on host, puppet('module','install','puppetlabs-stdlib'), { :acceptable_exit_codes => [0,1] }
     end
   end
 
   c.before(:all) do
     shell('mkdir -p /tmp/concat')
   end
   c.after(:all) do
     shell('rm -rf /tmp/concat /var/lib/puppet/concat')
   end
 
   c.treat_symbols_as_metadata_keys_with_true_values = true
 end
diff --git a/spec/unit/classes/concat_setup_spec.rb b/spec/unit/classes/concat_setup_spec.rb
index 3096e73..b25428e 100644
--- a/spec/unit/classes/concat_setup_spec.rb
+++ b/spec/unit/classes/concat_setup_spec.rb
@@ -1,84 +1,93 @@
 require 'spec_helper'
 
 describe 'concat::setup', :type => :class do
 
   shared_examples 'setup' do |concatdir|
     concatdir = '/foo' if concatdir.nil?
 
-    let(:facts) {{ :concat_basedir => concatdir }}
+    let(:facts) do
+      {
+        :concat_basedir     => concatdir,
+        :caller_module_name => 'Test',
+        :osfamily           => 'Debian',
+        :id                 => 'root',
+      }
+    end
 
     it do
       should contain_file("#{concatdir}/bin/concatfragments.sh").with({
         :mode   => '0755',
         :source => 'puppet:///modules/concat/concatfragments.sh',
         :backup => false,
       })
     end
 
     [concatdir, "#{concatdir}/bin"].each do |file|
       it do
         should contain_file(file).with({
           :ensure => 'directory',
           :mode   => '0755',
           :backup => false,
         })
       end
     end
   end
 
   context 'facts' do
     context 'concat_basedir =>' do
       context '/foo' do
         it_behaves_like 'setup', '/foo'
       end
     end
   end # facts
 
   context 'deprecated as a public class' do
     it 'should create a warning' do
       pending('rspec-puppet support for testing warning()')
     end
   end
 
   context "on osfamily Solaris" do
     concatdir = '/foo'
     let(:facts) do
       {
-        :concat_basedir => concatdir,
-        :osfamily       => 'Solaris',
-        :id             => 'root',
+        :concat_basedir     => concatdir,
+        :caller_module_name => 'Test',
+        :osfamily           => 'Solaris',
+        :id                 => 'root',
       }
     end
 
     it do
       should contain_file("#{concatdir}/bin/concatfragments.rb").with({
         :ensure => 'file',
         :owner  => 'root',
         :mode   => '0755',
         :source => 'puppet:///modules/concat/concatfragments.rb',
         :backup => false,
       })
     end
   end # on osfamily Solaris
 
   context "on osfamily windows" do
     concatdir = '/foo'
     let(:facts) do
       {
-        :concat_basedir => concatdir,
-        :osfamily       => 'windows',
-        :id             => 'batman',
+        :concat_basedir     => concatdir,
+        :caller_module_name => 'Test',
+        :osfamily           => 'windows',
+        :id                 => 'batman',
       }
     end
 
     it do
       should contain_file("#{concatdir}/bin/concatfragments.rb").with({
         :ensure => 'file',
         :owner  => nil,
         :mode   => nil,
         :source => 'puppet:///modules/concat/concatfragments.rb',
         :backup => false,
       })
     end
   end # on osfamily windows
 end
diff --git a/spec/unit/defines/concat_fragment_spec.rb b/spec/unit/defines/concat_fragment_spec.rb
index 3c61aab..64ae7db 100644
--- a/spec/unit/defines/concat_fragment_spec.rb
+++ b/spec/unit/defines/concat_fragment_spec.rb
@@ -1,267 +1,292 @@
 require 'spec_helper'
 
 describe 'concat::fragment', :type => :define do
 
   shared_examples 'fragment' do |title, params|
     params = {} if params.nil?
 
     p = {
       :content => nil,
       :source  => nil,
       :order   => 10,
       :ensure  => 'present',
     }.merge(params)
 
     safe_name        = title.gsub(/[\/\n]/, '_')
     safe_target_name = p[:target].gsub(/[\/\n]/, '_')
     concatdir        = '/var/lib/puppet/concat'
     fragdir          = "#{concatdir}/#{safe_target_name}"
     id               = 'root'
     if p[:ensure] == 'absent'
       safe_ensure = p[:ensure] 
     else
       safe_ensure = 'file'
     end
 
     let(:title) { title }
-    let(:facts) {{ :concat_basedir => concatdir, :id => id }}
+    let(:facts) do
+      {
+        :concat_basedir => concatdir,
+        :id             => id,
+        :osfamily       => 'Debian',
+        :path           => '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
+      }
+    end
     let(:params) { params }
     let(:pre_condition) do
       "concat{ '#{p[:target]}': }"
     end
 
     it do
       should contain_class('concat::setup')
       should contain_concat(p[:target])
       should contain_file("#{fragdir}/fragments/#{p[:order]}_#{safe_name}").with({
         :ensure  => safe_ensure,
         :owner   => id,
         :mode    => '0640',
         :source  => p[:source],
         :content => p[:content],
         :alias   => "concat_fragment_#{title}",
         :backup  => false,
       })
     end
   end
 
   context 'title' do
     ['0', '1', 'a', 'z'].each do |title|
       it_behaves_like 'fragment', title, {
         :target  => '/etc/motd',
       }
     end
   end # title
 
   context 'target =>' do
     ['./etc/motd', 'etc/motd', 'motd_header'].each do |target|
       context target do
         it_behaves_like 'fragment', target, {
           :target  => '/etc/motd',
         }
       end
     end
 
     context 'false' do
       let(:title) { 'motd_header' }
       let(:facts) {{ :concat_basedir => '/tmp' }}
       let(:params) {{ :target => false }}
 
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /is not a string/)
       end
     end
   end # target =>
 
   context 'ensure =>' do
     ['present', 'absent'].each do |ens|
       context ens do
         it_behaves_like 'fragment', 'motd_header', {
           :ensure => ens,
           :target => '/etc/motd',
         }
       end
     end
 
     context 'any value other than \'present\' or \'absent\'' do
       let(:title) { 'motd_header' }
       let(:facts) {{ :concat_basedir => '/tmp' }}
       let(:params) {{ :ensure => 'invalid', :target => '/etc/motd' }}
 
       it 'should create a warning' do
         pending('rspec-puppet support for testing warning()')
       end
     end
   end # ensure =>
 
   context 'content =>' do
     ['', 'ashp is our hero'].each do |content|
       context content do
         it_behaves_like 'fragment', 'motd_header', {
           :content => content,
           :target  => '/etc/motd',
         }
       end
     end
 
     context 'false' do
       let(:title) { 'motd_header' }
       let(:facts) {{ :concat_basedir => '/tmp' }}
       let(:params) {{ :content => false, :target => '/etc/motd' }}
 
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /is not a string/)
       end
     end
   end # content =>
 
   context 'source =>' do
     ['', '/foo/bar', ['/foo/bar', '/foo/baz']].each do |source|
       context source do
         it_behaves_like 'fragment', 'motd_header', {
           :source => source,
           :target => '/etc/motd',
         }
       end
     end
 
     context 'false' do
       let(:title) { 'motd_header' }
       let(:facts) {{ :concat_basedir => '/tmp' }}
       let(:params) {{ :source => false, :target => '/etc/motd' }}
 
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /is not a string or an Array/)
       end
     end
   end # source =>
 
   context 'order =>' do
     ['', '42', 'a', 'z'].each do |order|
       context '\'\'' do
         it_behaves_like 'fragment', 'motd_header', {
           :order  => order,
           :target => '/etc/motd',
         }
       end
     end
 
     context 'false' do
       let(:title) { 'motd_header' }
       let(:facts) {{ :concat_basedir => '/tmp' }}
       let(:params) {{ :order => false, :target => '/etc/motd' }}
 
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /is not a string or integer/)
       end
     end
   end # order =>
 
   context 'more than one content source' do
     error_msg = 'You cannot specify more than one of $content, $source, $ensure => /target'
 
     context 'ensure => target and source' do
       let(:title) { 'motd_header' }
-      let(:facts) {{ :concat_basedir => '/tmp' }}
+      let(:facts) do
+        {
+          :concat_basedir => '/tmp',
+          :osfamily       => 'Debian',
+          :id             => 'root',
+        }
+      end
       let(:params) do
         {
           :target  => '/etc/motd',
           :ensure  => '/foo',
           :source  => '/bar',
         }
       end
 
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /#{Regexp.escape(error_msg)}/m)
       end
     end
 
     context 'ensure => target and content' do
       let(:title) { 'motd_header' }
-      let(:facts) {{ :concat_basedir => '/tmp' }}
+      let(:facts) do
+        {
+          :concat_basedir => '/tmp',
+          :osfamily       => 'Debian',
+          :id             => 'root',
+        }
+      end
       let(:params) do
         {
           :target  => '/etc/motd',
           :ensure  => '/foo',
           :content => 'bar',
         }
       end
 
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /#{Regexp.escape(error_msg)}/m)
       end
     end
 
     context 'source and content' do
       let(:title) { 'motd_header' }
-      let(:facts) {{ :concat_basedir => '/tmp' }}
+      let(:facts) do
+        {
+          :concat_basedir => '/tmp',
+          :osfamily       => 'Debian',
+          :id             => 'root',
+        }
+      end
       let(:params) do
         {
           :target => '/etc/motd',
           :source => '/foo',
           :content => 'bar',
         }
       end
 
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /#{Regexp.escape(error_msg)}/m)
       end
     end
 
   end # more than one content source
 
   describe 'deprecated parameter' do
     context 'mode =>' do
       context '1755' do
         it_behaves_like 'fragment', 'motd_header', {
           :mode   => '1755',
           :target => '/etc/motd',
         }
 
         it 'should create a warning' do
           pending('rspec-puppet support for testing warning()')
         end
       end
     end # mode =>
 
     context 'owner =>' do
       context 'apenny' do
         it_behaves_like 'fragment', 'motd_header', {
           :owner  => 'apenny',
           :target => '/etc/motd',
         }
 
         it 'should create a warning' do
           pending('rspec-puppet support for testing warning()')
         end
       end
     end # owner =>
 
     context 'group =>' do
       context 'apenny' do
         it_behaves_like 'fragment', 'motd_header', {
           :group  => 'apenny',
           :target => '/etc/motd',
         }
 
         it 'should create a warning' do
           pending('rspec-puppet support for testing warning()')
         end
       end
     end # group =>
 
     context 'backup =>' do
       context 'foo' do
         it_behaves_like 'fragment', 'motd_header', {
           :backup => 'foo',
           :target => '/etc/motd',
         }
 
         it 'should create a warning' do
           pending('rspec-puppet support for testing warning()')
         end
       end
     end # backup =>
   end # deprecated params
 
 end
diff --git a/spec/unit/defines/concat_spec.rb b/spec/unit/defines/concat_spec.rb
index e7be4d5..7682cdf 100644
--- a/spec/unit/defines/concat_spec.rb
+++ b/spec/unit/defines/concat_spec.rb
@@ -1,389 +1,397 @@
 require 'spec_helper'
 
 describe 'concat', :type => :define do
 
   shared_examples 'concat' do |title, params, id| 
     params = {} if params.nil?
     id = 'root' if id.nil?
 
     # default param values
     p = {
       :ensure         => 'present',
       :path           => title,
       :owner          => nil,
       :group          => nil,
       :mode           => '0644',
       :warn           => false,
       :force          => false,
       :backup         => 'puppet',
       :replace        => true,
       :order          => 'alpha',
       :ensure_newline => false,
     }.merge(params)
 
     safe_name            = title.gsub('/', '_')
     concatdir            = '/var/lib/puppet/concat'
     fragdir              = "#{concatdir}/#{safe_name}"
     concat_name          = 'fragments.concat.out'
     default_warn_message = '# This file is managed by Puppet. DO NOT EDIT.'
 
     file_defaults = {
       :backup  => false,
     }
 
     let(:title) { title }
     let(:params) { params }
-    let(:facts) {{ :concat_basedir => concatdir, :id => id }}
+    let(:facts) do
+      {
+        :concat_basedir => concatdir,
+        :id             => id,
+        :osfamily       => 'Debian',
+        :path           => '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
+        :kernel         => 'Linux',
+      }
+    end
 
     if p[:ensure] == 'present'
       it do
         should contain_file(fragdir).with(file_defaults.merge({
           :ensure => 'directory',
           :mode   => '0750',
         }))
       end
 
       it do
         should contain_file("#{fragdir}/fragments").with(file_defaults.merge({
           :ensure  => 'directory',
           :mode    => '0750',
           :force   => true,
           :ignore  => ['.svn', '.git', '.gitignore'],
           :purge   => true,
           :recurse => true,
         }))
       end
 
       [
         "#{fragdir}/fragments.concat",
         "#{fragdir}/#{concat_name}",
       ].each do |file|
         it do
           should contain_file(file).with(file_defaults.merge({
             :ensure => 'present',
             :mode   => '0640',
           }))
         end
       end
 
       it do
         should contain_file(title).with(file_defaults.merge({
           :ensure  => 'present',
           :owner   => p[:owner],
           :group   => p[:group],
           :mode    => p[:mode],
           :replace => p[:replace],
           :path    => p[:path],
           :alias   => "concat_#{title}",
           :source  => "#{fragdir}/#{concat_name}",
           :backup  => p[:backup],
         }))
       end
 
       cmd = "#{concatdir}/bin/concatfragments.sh " +
             "-o \"#{concatdir}/#{safe_name}/fragments.concat.out\" " +
             "-d \"#{concatdir}/#{safe_name}\""
 
       # flag order: fragdir, warnflag, forceflag, orderflag, newlineflag 
       if p.has_key?(:warn)
         case p[:warn]
         when TrueClass
           message = default_warn_message
         when 'true', 'yes', 'on'
           # should generate a stringified boolean warning
           message = default_warn_message
         when FalseClass
           message = nil
         when 'false', 'no', 'off'
           # should generate a stringified boolean warning
           message = nil
         else
           message = p[:warn]
         end
 
         unless message.nil?
           cmd += " -w \'#{message}\'"
         end
       end
 
       cmd += " -f" if p[:force]
       cmd += " -n" if p[:order] == 'numeric'
       cmd += " -l" if p[:ensure_newline] == true
 
       it do
         should contain_exec("concat_#{title}").with({
           :alias   => "concat_#{fragdir}",
           :command => cmd,
           :unless  => "#{cmd} -t",
         })
       end
     else
       [
         fragdir,
         "#{fragdir}/fragments",
         "#{fragdir}/fragments.concat",
         "#{fragdir}/#{concat_name}",
       ].each do |file|
         it do
           should contain_file(file).with(file_defaults.merge({
             :ensure => 'absent',
             :backup => false,
             :force  => true,
           }))
         end
       end
 
       it do
         should contain_file(title).with(file_defaults.merge({
           :ensure => 'absent',
           :backup => p[:backup],
         }))
       end
 
       it do
         should contain_exec("concat_#{title}").with({
           :alias   => "concat_#{fragdir}",
           :command => 'true',
           :unless  => 'true',
           :path    => '/bin:/usr/bin',
         })
       end
     end
   end
 
   context 'title' do
     context 'without path param' do
       # title/name is the default value for the path param. therefore, the
       # title must be an absolute path unless path is specified
       ['/foo', '/foo/bar', '/foo/bar/baz'].each do |title|
         context title do
           it_behaves_like 'concat', '/etc/foo.bar'
         end
       end
 
       ['./foo', 'foo', 'foo/bar'].each do |title|
         context title do
           let(:title) { title }
           it 'should fail' do
             expect { should }.to raise_error(Puppet::Error, /is not an absolute path/)
           end
         end
       end
     end
 
     context 'with path param' do
       ['./foo', 'foo', 'foo/bar'].each do |title|
         context title do
           it_behaves_like 'concat', title, { :path => '/etc/foo.bar' }
         end
       end
     end
   end # title =>
 
   context 'as non-root user' do
     it_behaves_like 'concat', '/etc/foo.bar', {}, 'bob'
   end
 
   context 'ensure =>' do
     ['present', 'absent'].each do |ens|
       context ens do
         it_behaves_like 'concat', '/etc/foo.bar', { :ensure => ens }
       end
     end
 
     context 'invalid' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :ensure => 'invalid' }}
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /#{Regexp.escape('does not match "^present$|^absent$"')}/)
       end
     end
   end # ensure =>
 
   context 'path =>' do
     context '/foo' do
       it_behaves_like 'concat', '/etc/foo.bar', { :path => '/foo' }
     end
 
     ['./foo', 'foo', 'foo/bar', false].each do |path|
       context path do
         let(:title) { '/etc/foo.bar' }
         let(:params) {{ :path => path }}
         it 'should fail' do
           expect { should }.to raise_error(Puppet::Error, /is not an absolute path/)
         end
       end
     end
   end # path =>
 
   context 'owner =>' do
     context 'apenney' do
       it_behaves_like 'concat', '/etc/foo.bar', { :owner => 'apenny' }
     end
 
     context 'false' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :owner => false }}
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /is not a string/)
       end
     end
   end # owner =>
 
   context 'group =>' do
     context 'apenney' do
       it_behaves_like 'concat', '/etc/foo.bar', { :group => 'apenny' }
     end
 
     context 'false' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :group => false }}
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /is not a string/)
       end
     end
   end # group =>
 
   context 'mode =>' do
     context '1755' do
       it_behaves_like 'concat', '/etc/foo.bar', { :mode => '1755' }
     end
 
     context 'false' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :mode => false }}
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /is not a string/)
       end
     end
   end # mode =>
 
   context 'warn =>' do
     [true, false, '# foo'].each do |warn|
       context warn do
         it_behaves_like 'concat', '/etc/foo.bar', { :warn => warn }
       end
     end
 
     context '(stringified boolean)' do
       ['true', 'yes', 'on', 'false', 'no', 'off'].each do |warn|
         context warn do
           it_behaves_like 'concat', '/etc/foo.bar', { :warn => warn }
 
           it 'should create a warning' do
             pending('rspec-puppet support for testing warning()')
           end
         end
       end
     end
 
     context '123' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :warn => 123 }}
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /is not a string or boolean/)
       end
     end
   end # warn =>
 
   context 'force =>' do
     [true, false].each do |force|
       context force do
         it_behaves_like 'concat', '/etc/foo.bar', { :force => force }
       end
     end
 
     context '123' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :force => 123 }}
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /is not a boolean/)
       end
     end
   end # force =>
 
   context 'backup =>' do
     context 'reverse' do
       it_behaves_like 'concat', '/etc/foo.bar', { :backup => 'reverse' }
     end
 
     context 'false' do
       it_behaves_like 'concat', '/etc/foo.bar', { :backup => false }
     end
 
     context 'true' do
       it_behaves_like 'concat', '/etc/foo.bar', { :backup => true }
     end
 
     context 'true' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :backup => [] }}
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /backup must be string or bool/)
       end
     end
   end # backup =>
 
   context 'replace =>' do
     [true, false].each do |replace|
       context replace do
         it_behaves_like 'concat', '/etc/foo.bar', { :replace => replace }
       end
     end
 
     context '123' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :replace => 123 }}
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /is not a boolean/)
       end
     end
   end # replace =>
 
   context 'order =>' do
     ['alpha', 'numeric'].each do |order|
       context order do
         it_behaves_like 'concat', '/etc/foo.bar', { :order => order }
       end
     end
 
     context 'invalid' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :order => 'invalid' }}
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /#{Regexp.escape('does not match "^alpha$|^numeric$"')}/)
       end
     end
   end # order =>
 
   context 'ensure_newline =>' do
     [true, false].each do |ensure_newline|
       context 'true' do
         it_behaves_like 'concat', '/etc/foo.bar', { :ensure_newline => ensure_newline}
       end
     end
 
     context '123' do
       let(:title) { '/etc/foo.bar' }
       let(:params) {{ :ensure_newline => 123 }}
       it 'should fail' do
         expect { should }.to raise_error(Puppet::Error, /is not a boolean/)
       end
     end
   end # ensure_newline =>
 
   describe 'deprecated parameter' do
     context 'gnu =>' do
       context 'foo' do
         it_behaves_like 'concat', '/etc/foo.bar', { :gnu => 'foo'}
 
         it 'should create a warning' do
           pending('rspec-puppet support for testing warning()')
         end
       end
     end
   end
 
 end
 
 # vim:sw=2:ts=2:expandtab:textwidth=79