chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/spec/functional/resource/aix_service_spec.rb

@@ -0,0 +1,136 @@
+# encoding: UTF-8
+#
+# Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'functional/resource/base'
+require 'chef/mixin/shell_out'
+
+shared_examples "src service" do
+
+  include Chef::Mixin::ShellOut
+
+  def service_should_be_started
+    expect(shell_out!("lssrc -a | grep #{new_resource.service_name}").stdout.split(' ').last).to eq("active")
+  end
+
+  def service_should_be_stopped
+    expect(shell_out!("lssrc -a | grep #{new_resource.service_name}").stdout.split(' ').last).to eq("inoperative")
+  end
+
+  def get_service_pid
+    args = shell_out!("lssrc -a | grep #{new_resource.service_name}").stdout.split(' ')
+    if args.length == 3
+      args[1]
+    else
+      args[2]
+    end
+  end
+
+  describe "start service" do
+    it "should start the service" do
+      new_resource.run_action(:start)
+      service_should_be_started
+    end
+  end
+
+  describe "stop service" do
+    before do
+      new_resource.run_action(:start)
+    end
+
+    it "should stop the service" do
+      new_resource.run_action(:stop)
+      service_should_be_stopped
+    end
+  end
+
+  describe "restart service" do
+    before do
+      new_resource.run_action(:start)
+    end
+
+    it "should restart the service" do
+      new_resource.run_action(:restart)
+      service_should_be_started
+    end
+  end
+end
+
+describe Chef::Resource::Service, :requires_root, :aix_only do
+  def get_user_id
+    shell_out("id -u #{ENV['USER']}").stdout.chomp
+  end
+
+  describe "When service is a subsystem" do
+    before(:all) do
+      script_dir = File.join(File.dirname(__FILE__), "/../assets/")
+      shell_out!("mkssys -s ctestsys -p #{script_dir}/testchefsubsys -u #{get_user_id} -S -n 15 -f 9 -R -Q")
+    end
+
+    after(:each) do
+      shell_out("stopsrc -s ctestsys")
+    end
+
+    after(:all) do
+      shell_out!("rmssys -s ctestsys")
+    end
+
+
+    let(:new_resource) do
+      new_resource = Chef::Resource::Service.new("ctestsys", run_context)
+      new_resource
+    end
+
+    let(:provider) do
+      provider = new_resource.provider_for_action(new_resource.action)
+      provider
+    end
+
+    it_behaves_like "src service"
+  end
+
+
+  describe "When service is a group" do
+    before(:all) do
+      script_dir = File.join(File.dirname(__FILE__), "/../assets/")
+      shell_out!("mkssys -s ctestsys -p #{script_dir}/testchefsubsys -u #{get_user_id} -S -n 15 -f 9 -R -Q -G ctestgrp")
+    end
+
+    after(:each) do
+      shell_out("stopsrc -g ctestgrp")
+    end
+
+    after(:all) do
+      # rmssys supports only -s option.
+      shell_out!("rmssys -s ctestsys")
+    end
+
+    let(:new_resource) do
+      new_resource = Chef::Resource::Service.new("ctestgrp", run_context)
+      new_resource
+    end
+
+    let(:provider) do
+      provider = new_resource.provider_for_action(new_resource.action)
+      provider
+    end
+
+    it_behaves_like "src service"
+  end
+end

data/spec/functional/resource/aixinit_service_spec.rb

@@ -0,0 +1,211 @@
+# encoding: UTF-8
+#
+# Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'functional/resource/base'
+require 'chef/mixin/shell_out'
+require 'fileutils'
+
+describe Chef::Resource::Service, :requires_root, :aix_only do
+
+  include Chef::Mixin::ShellOut
+
+  # Platform specific validation routines.
+  def service_should_be_started(file_name)
+    # The existance of this file indicates that the service was started.
+    expect(File.exists?("/tmp/#{file_name}")).to be_true
+  end
+
+  def service_should_be_stopped(file_name)
+    expect(File.exists?("/tmp/#{file_name}")).to be_false
+  end
+
+  def valide_symlinks(expected_output, run_level = nil, status = nil, priority = nil)
+    directory = []
+    if priority.is_a?Hash
+      priority.each do |level,o|
+        directory << "/etc/rc.d/rc#{level}.d/#{(o[0] == :start ? 'S' : 'K')}#{o[1]}#{new_resource.service_name}"
+      end
+      directory
+    else
+      directory << "/etc/rc.d/rc#{run_level}.d/#{status}#{priority}#{new_resource.service_name}"
+    end
+    expect(Dir.glob(directory)).to eq(expected_output)
+    File.delete(*directory)
+  end
+
+  def delete_test_files
+    files = Dir.glob("/tmp/chefinit[a-z_]*.txt")
+    File.delete(*files)
+  end
+
+  # Actual tests
+  let(:new_resource) do
+    new_resource = Chef::Resource::Service.new("chefinittest", run_context)
+    new_resource.provider Chef::Provider::Service::AixInit
+    new_resource.supports({:status => true, :restart => true, :reload => true})
+    new_resource
+  end
+
+  let(:provider) do
+    provider = new_resource.provider_for_action(new_resource.action)
+    provider
+  end
+
+  before(:all) do
+    File.delete("/etc/rc.d/init.d/chefinittest") if File.exists?("/etc/rc.d/init.d/chefinittest")
+    FileUtils.cp("#{File.join(File.dirname(__FILE__), "/../assets/chefinittest")}",  "/etc/rc.d/init.d/chefinittest")
+  end
+
+  after(:all) do
+    File.delete("/etc/rc.d/init.d/chefinittest") if File.exists?("/etc/rc.d/init.d/chefinittest")
+  end
+
+  before(:each) do
+    delete_test_files
+  end
+
+  after(:each) do
+    delete_test_files
+  end
+
+  describe "start service" do
+    it "should start the service" do
+      new_resource.run_action(:start)
+      service_should_be_started("chefinittest.txt")
+    end
+  end
+
+  describe "stop service" do
+    before do
+      new_resource.run_action(:start)
+    end
+
+    it "should stop the service" do
+      new_resource.run_action(:stop)
+      service_should_be_stopped("chefinittest.txt")
+    end
+  end
+
+  describe "restart service" do
+    before do
+      new_resource.run_action(:start)
+    end
+
+    it "should restart the service" do
+      new_resource.run_action(:restart)
+      service_should_be_started("chefinittest_restart.txt")
+    end
+  end
+
+  describe "reload service" do
+    before do
+      new_resource.run_action(:start)
+    end
+
+    it "should reload the service" do
+      new_resource.run_action(:reload)
+      service_should_be_started("chefinittest_reload.txt")
+    end
+  end
+
+  describe "enable service" do
+
+    context "when the service doesn't set a priority" do
+      it "creates symlink with status S" do
+        new_resource.run_action(:enable)
+        valide_symlinks(["/etc/rc.d/rc2.d/Schefinittest"],2,'S')
+      end
+    end
+
+    context "when the service sets a simple priority (integer)" do
+      before do
+        new_resource.priority(75)
+      end
+
+      it "creates a symlink with status S and a priority" do
+        new_resource.run_action(:enable)
+        valide_symlinks(["/etc/rc.d/rc2.d/S75chefinittest"], 2,'S',75)
+      end
+    end
+
+    context "when the service sets complex priorities (hash)" do
+      before do
+        priority = {2 => [:start, 20], 3 => [:stop, 10]}
+        new_resource.priority(priority)
+      end
+
+      it "create symlink with status start (S) or stop (K) and a priority " do
+        new_resource.run_action(:enable)
+        valide_symlinks(["/etc/rc.d/rc2.d/S20chefinittest", "/etc/rc.d/rc3.d/K10chefinittest"], 2,'S',new_resource.priority)
+      end
+    end
+  end
+
+  describe "disable_service" do
+
+    context "when the service doesn't set a priority" do
+      before do
+        File.symlink("/etc/rc.d/init.d/chefinittest", "/etc/rc.d/rc2.d/Schefinittest")
+      end
+
+      after do
+        File.delete("/etc/rc.d/rc2.d/Schefinittest") if File.exists?("/etc/rc.d/rc2.d/chefinittest")
+      end
+
+      it "creates symlink with status K" do
+        new_resource.run_action(:disable)
+        valide_symlinks(["/etc/rc.d/rc2.d/Kchefinittest"], 2,'K')
+      end
+    end
+
+    context "when the service sets a simple priority (integer)" do
+      before do
+        new_resource.priority(75)
+        File.symlink("/etc/rc.d/init.d/chefinittest", "/etc/rc.d/rc2.d/Schefinittest")
+      end
+
+      after do
+        File.delete("/etc/rc.d/rc2.d/Schefinittest") if File.exists?("/etc/rc.d/rc2.d/chefinittest")
+      end
+
+      it "creates a symlink with status K and a priority" do
+        new_resource.run_action(:disable)
+        valide_symlinks(["/etc/rc.d/rc2.d/K25chefinittest"], 2,'K',25)
+      end
+    end
+
+    context "when the service sets complex priorities (hash)" do
+      before do
+        @priority = {2 => [:stop, 20], 3 => [:start, 10]}
+        new_resource.priority(@priority)
+        File.symlink("/etc/rc.d/init.d/chefinittest", "/etc/rc.d/rc2.d/Schefinittest")
+      end
+
+      after do
+        File.delete("/etc/rc.d/rc2.d/Schefinittest") if File.exists?("/etc/rc.d/rc2.d/chefinittest")
+      end
+
+      it "create symlink with status stop (K) and a priority " do
+        new_resource.run_action(:disable)
+        valide_symlinks(["/etc/rc.d/rc2.d/K80chefinittest"], 2,'K',80)
+      end
+    end
+  end
+end

data/spec/functional/resource/base.rb

@@ -22,6 +22,7 @@ def run_context
     node = Chef::Node.new
     node.default[:platform] = ohai[:platform]
     node.default[:platform_version] = ohai[:platform_version]
+    node.default[:os] = ohai[:os]
     events = Chef::EventDispatch::Dispatcher.new
     Chef::RunContext.new(node, {}, events)
   end

data/spec/functional/resource/batch_spec.rb

@@ -21,17 +21,10 @@ require 'spec_helper'
 describe Chef::Resource::WindowsScript::Batch, :windows_only do
   include_context Chef::Resource::WindowsScript
 
-  let(:script_content) { "whoami" }
+  let(:output_command) { ' > ' }
 
-  let!(:resource) do
-    Chef::Resource::WindowsScript::Batch.new("Batch resource functional test", @run_context)
-  end
+  let (:architecture_command) { '@echo %PROCESSOR_ARCHITECTURE%' }
+
+  it_behaves_like "a Windows script running on Windows"
 
-  describe "when the run action is invoked on Windows" do
-    it "executes the script code" do
-      resource.code(script_content + " > #{script_output_path}")
-      resource.returns(0)
-      resource.run_action(:run)
-    end
-  end
 end

data/spec/functional/resource/cron_spec.rb

@@ -17,6 +17,7 @@
 # limitations under the License.
 #
 
+require 'spec_helper'
 require 'functional/resource/base'
 require 'chef/mixin/shell_out'
 
@@ -55,7 +56,12 @@ describe Chef::Resource::Cron, :requires_root, :unix_only do
   let(:new_resource) do
     new_resource = Chef::Resource::Cron.new("Chef functional test cron", run_context)
     new_resource.user  'root'
-    new_resource.minute '@hourly'
+    # @hourly is not supported on solaris, aix
+    if ohai[:platform] == "solaris" || ohai[:platform] == "solaris2" || ohai[:platform] == "aix"
+      new_resource.minute "0 * * * *"
+    else
+      new_resource.minute '@hourly'
+    end
     new_resource.hour ''
     new_resource.day ''
     new_resource.month ''

data/spec/functional/resource/dsc_script_spec.rb

@@ -0,0 +1,382 @@
+#
+# Author:: Adam Edwards (<adamed@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'chef/mixin/shell_out'
+require 'chef/mixin/windows_architecture_helper'
+
+describe Chef::Resource::DscScript, :windows_powershell_dsc_only do
+  include Chef::Mixin::WindowsArchitectureHelper
+  before(:all) do
+    @temp_dir = ::Dir.mktmpdir("dsc-functional-test")
+  end
+
+  after(:all) do
+    ::FileUtils.rm_rf(@temp_dir) if ::Dir.exist?(@temp_dir)
+  end
+
+  include Chef::Mixin::ShellOut
+
+  def create_config_script_from_code(code, configuration_name, data = false)
+    script_code = data ? code : "Configuration '#{configuration_name}'\n{\n\t#{code}\n}\n"
+    data_suffix = data ? '_config_data' : ''
+    extension = data ? 'psd1' : 'ps1'
+    script_path = "#{@temp_dir}/dsc_functional_test#{data_suffix}.#{extension}"
+    ::File.open(script_path, 'wt') do | script |
+      script.write(script_code)
+    end
+    script_path
+  end
+
+  def user_exists?(target_user)
+    result = false
+    begin
+      shell_out!("net user #{target_user}")
+      result = true
+    rescue Mixlib::ShellOut::ShellCommandFailed
+    end
+    result
+  end
+
+  def delete_user(target_user)
+    begin
+      shell_out!("net user #{target_user} /delete")
+    rescue Mixlib::ShellOut::ShellCommandFailed
+    end
+  end
+
+  let(:dsc_env_variable) { 'chefenvtest' }
+  let(:dsc_env_value1) { 'value1' }
+  let(:env_value2) { 'value2' }
+  let(:dsc_test_run_context) {
+    node = Chef::Node.new
+    node.automatic['platform'] = 'windows'
+    node.automatic['platform_version'] = '6.1'
+    node.automatic['kernel'][:machine] =
+      is_i386_process_on_x86_64_windows? ? :x86_64 : :i386
+    node.automatic[:languages][:powershell][:version] = '4.0'
+    empty_events = Chef::EventDispatch::Dispatcher.new
+    Chef::RunContext.new(node, {}, empty_events)
+  }
+  let(:dsc_test_resource_name) { 'DSCTest' }
+  let(:dsc_test_resource_base) {
+    Chef::Resource::DscScript.new(dsc_test_resource_name, dsc_test_run_context)
+  }
+  let(:test_registry_key) { 'HKEY_LOCAL_MACHINE\Software\Chef\Spec\Functional\Resource\dsc_script_spec' }
+  let(:test_registry_value) { 'Registration' }
+  let(:test_registry_data1) { 'LL927' }
+  let(:test_registry_data2) { 'LL928' }
+  let(:reg_key_name_param_name) { 'testregkeyname' }
+  let(:reg_key_value_param_name) { 'testregvaluename' }
+  let(:registry_embedded_parameters) { "$#{reg_key_name_param_name} = '#{test_registry_key}';$#{reg_key_value_param_name} = '#{test_registry_value}'"}
+  let(:dsc_reg_code) { <<-EOH
+  #{registry_embedded_parameters}
+  Registry "ChefRegKey"
+  {
+     Key = $#{reg_key_name_param_name}
+     ValueName = $#{reg_key_value_param_name}
+     ValueData = '#{test_registry_data}'
+     Ensure = 'Present'
+  }
+EOH
+  }
+
+  let(:dsc_code) { dsc_reg_code }
+  let(:dsc_reg_script) { <<-EOH
+  param($testregkeyname, $testregvaluename)
+  #{dsc_reg_code}
+EOH
+      }
+
+  let(:dsc_user_prefix) { 'dsc' }
+  let(:dsc_user_suffix) { 'chefx' }
+  let(:dsc_user) {"#{dsc_user_prefix}_usr_#{dsc_user_suffix}" }
+  let(:dsc_user_prefix_env_var_name) { 'dsc_user_env_prefix' }
+  let(:dsc_user_suffix_env_var_name) { 'dsc_user_env_suffix' }
+  let(:dsc_user_prefix_env_code) { "$env:#{dsc_user_prefix_env_var_name}"}
+  let(:dsc_user_suffix_env_code) { "$env:#{dsc_user_suffix_env_var_name}"}
+  let(:dsc_user_prefix_param_name) { 'dsc_user_prefix_param' }
+  let(:dsc_user_suffix_param_name) { 'dsc_user_suffix_param' }
+  let(:dsc_user_prefix_param_code) { "$#{dsc_user_prefix_param_name}"}
+  let(:dsc_user_suffix_param_code) { "$#{dsc_user_suffix_param_name}"}
+  let(:dsc_user_env_code) { "\"$(#{dsc_user_prefix_env_code})_usr_$(#{dsc_user_suffix_env_code})\""}
+  let(:dsc_user_param_code) { "\"$(#{dsc_user_prefix_param_code})_usr_$(#{dsc_user_suffix_param_code})\""}
+
+  let(:config_flags) { nil }
+  let(:config_params) { <<-EOH
+
+    [CmdletBinding()]
+    param
+    (
+    $#{dsc_user_prefix_param_name},
+    $#{dsc_user_suffix_param_name}
+    )
+EOH
+  }
+
+  let(:config_param_section) { '' }
+  let(:dsc_user_code) { "'#{dsc_user}'" }
+  let(:dsc_user_prefix_code) { dsc_user_prefix }
+  let(:dsc_user_suffix_code) { dsc_user_suffix }
+  let(:dsc_script_environment_attribute) { nil }
+  let(:dsc_user_resources_code) { <<-EOH
+  #{config_param_section}
+node localhost
+{
+$testuser = #{dsc_user_code}
+$testpassword = ConvertTo-SecureString -String "jf9a8m49jrajf4#" -AsPlainText -Force
+$testcred = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $testuser, $testpassword
+
+User dsctestusercreate
+{
+    UserName = $testuser
+    Password = $testcred
+    Description = "DSC test user"
+    Ensure = "Present"
+    Disabled = $false
+    PasswordNeverExpires = $true
+    PasswordChangeRequired = $false
+}
+}
+EOH
+  }
+
+  let(:dsc_user_config_data) {
+<<-EOH
+@{
+    AllNodes = @(
+        @{
+            NodeName = "localhost";
+            PSDscAllowPlainTextPassword = $true
+        }
+    )
+}
+
+EOH
+  }
+
+  let(:dsc_environment_env_var_name) { 'dsc_test_cwd' }
+  let(:dsc_environment_no_fail_not_etc_directory) { "#{ENV['systemroot']}\\system32" }
+  let(:dsc_environment_fail_etc_directory) { "#{ENV['systemroot']}\\system32\\drivers\\etc" }
+  let(:exception_message_signature) { 'LL927-LL928' }
+  let(:dsc_environment_config) {<<-EOH
+if (($pwd.path -eq '#{dsc_environment_fail_etc_directory}') -and (test-path('#{dsc_environment_fail_etc_directory}')))
+{
+    throw 'Signature #{exception_message_signature}: Purposefully failing because cwd == #{dsc_environment_fail_etc_directory}'
+}
+environment "whatsmydir"
+{
+    Name = '#{dsc_environment_env_var_name}'
+    Value = $pwd.path
+    Ensure = 'Present'
+}
+EOH
+}
+
+  let(:dsc_config_name) {
+    dsc_test_resource_base.name
+  }
+  let(:dsc_resource_from_code) {
+    dsc_test_resource_base.code(dsc_code)
+    dsc_test_resource_base
+  }
+  let(:config_name_value) { dsc_test_resource_base.name }
+
+  let(:dsc_resource_from_path) {
+    dsc_test_resource_base.command(create_config_script_from_code(dsc_code, config_name_value))
+    dsc_test_resource_base
+  }
+
+  before(:each) do
+    test_key_resource = Chef::Resource::RegistryKey.new(test_registry_key, dsc_test_run_context)
+    test_key_resource.recursive(true)
+    test_key_resource.run_action(:delete_key)
+  end
+
+  after(:each) do
+    test_key_resource = Chef::Resource::RegistryKey.new(test_registry_key, dsc_test_run_context)
+    test_key_resource.recursive(true)
+    test_key_resource.run_action(:delete_key)
+  end
+
+  shared_examples_for 'a dsc_script resource with specified PowerShell configuration code' do
+    let(:test_registry_data) { test_registry_data1 }
+    it 'should create a registry key with a specific registry value and data' do
+      expect(dsc_test_resource.registry_key_exists?(test_registry_key)).to eq(false)
+      dsc_test_resource.run_action(:run)
+      expect(dsc_test_resource.registry_key_exists?(test_registry_key)).to eq(true)
+      expect(dsc_test_resource.registry_value_exists?(test_registry_key, {:name => test_registry_value, :type => :string, :data => test_registry_data})).to eq(true)
+    end
+
+    it_should_behave_like 'a dsc_script resource with configuration affected by cwd'
+  end
+
+  shared_examples_for 'a dsc_script resource with configuration affected by cwd' do
+    after(:each) do
+      removal_resource = Chef::Resource::DscScript.new(dsc_test_resource_name, dsc_test_run_context)
+      removal_resource.code <<-EOH
+environment 'removethis'
+{
+   Name = '#{dsc_environment_env_var_name}'
+   Ensure = 'Absent'
+}
+EOH
+      removal_resource.run_action(:run)
+    end
+
+    describe 'when the DSC configuration contains code that raises an exception if cwd has a specific value' do
+      let(:dsc_code) { dsc_environment_config }
+      it 'should not raise an exception if the cwd is not etc' do
+        dsc_test_resource.cwd(dsc_environment_no_fail_not_etc_directory)
+        expect {dsc_test_resource.run_action(:run)}.not_to raise_error
+      end
+
+      it 'should raise an exception if the cwd is etc' do
+        dsc_test_resource.cwd(dsc_environment_fail_etc_directory)
+        expect {dsc_test_resource.run_action(:run)}.to raise_error(Chef::Exceptions::PowershellCmdletException)
+        begin
+          dsc_test_resource.run_action(:run)
+        rescue Chef::Exceptions::PowershellCmdletException => e
+          expect(e.message).to match(exception_message_signature)
+        end
+      end
+    end
+  end
+
+  shared_examples_for 'a parameterized DSC configuration script' do
+    let(:dsc_user_prefix_code) { dsc_user_prefix_env_code }
+    let(:dsc_user_suffix_code) { dsc_user_suffix_env_code }
+    it_behaves_like 'a dsc_script with configuration that uses environment variables'
+  end
+
+  shared_examples_for 'a dsc_script without configuration data that takes parameters' do
+    context 'when configuration data is not specified' do
+
+      before(:each) do
+        test_key_resource = Chef::Resource::RegistryKey.new(test_registry_key, dsc_test_run_context)
+        test_key_resource.recursive(true)
+        test_key_resource.run_action(:delete_key)
+      end
+
+      after(:each) do
+        test_key_resource = Chef::Resource::RegistryKey.new(test_registry_key, dsc_test_run_context)
+        test_key_resource.recursive(true)
+        test_key_resource.run_action(:delete_key)
+      end
+
+      let(:test_registry_data) { test_registry_data1 }
+      let(:dsc_parameterized_env_param_value) { "val" + Random::rand.to_s  }
+
+      it 'should have a default value of nil for the configuration_data attribute' do
+        expect(dsc_test_resource.configuration_data).to eql(nil)
+      end
+
+      it 'should have a default value of nil for the configuration_data_path attribute' do
+        expect(dsc_test_resource.configuration_data_script).to eql(nil)
+      end
+
+      let(:dsc_test_resource) { dsc_resource_from_path }
+      let(:registry_embedded_parameters) { '' }
+      let(:dsc_code) { dsc_reg_script }
+
+      it 'should set a registry key according to parameters passed to the configuration' do
+        dsc_test_resource.configuration_name(config_name_value)
+      dsc_test_resource.flags({:"#{reg_key_name_param_name}" => test_registry_key, :"#{reg_key_value_param_name}" => test_registry_value})
+        expect(dsc_test_resource.registry_key_exists?(test_registry_key)).to eq(false)
+        dsc_test_resource.run_action(:run)
+        expect(dsc_test_resource.registry_key_exists?(test_registry_key)).to eq(true)
+        expect(dsc_test_resource.registry_value_exists?(test_registry_key, {:name => test_registry_value, :type => :string, :data => test_registry_data})).to eq(true)
+      end
+    end
+  end
+
+  shared_examples_for 'a dsc_script with configuration data' do
+    let(:configuration_data_attribute) { 'configuration_data' }
+    it_behaves_like 'a dsc_script with configuration data set via an attribute'
+
+    let(:configuration_data_attribute) { 'configuration_data_script' }
+    it_behaves_like 'a dsc_script with configuration data set via an attribute'
+  end
+
+  shared_examples_for 'a dsc_script with configuration data set via an attribute' do
+    it 'should run a configuration script that creates a user' do
+      config_data_value = dsc_user_config_data
+      dsc_test_resource.configuration_name(config_name_value)
+      if configuration_data_attribute == 'configuration_data_script'
+        config_data_value = create_config_script_from_code(dsc_user_config_data, '', true)
+      end
+      dsc_test_resource.environment({dsc_user_prefix_env_var_name => dsc_user_prefix,
+                                      dsc_user_suffix_env_var_name => dsc_user_suffix})
+      dsc_test_resource.send(configuration_data_attribute, config_data_value)
+      dsc_test_resource.flags(config_flags)
+      expect(user_exists?(dsc_user)).to eq(false)
+      expect {dsc_test_resource.run_action(:run)}.not_to raise_error
+      expect(user_exists?(dsc_user)).to eq(true)
+    end
+  end
+
+  shared_examples_for 'a dsc_script with configuration data that takes parameters' do
+    let(:dsc_user_code) { dsc_user_param_code }
+    let(:config_param_section) { config_params }
+    let(:config_flags) {{:"#{dsc_user_prefix_param_name}" => "#{dsc_user_prefix}", :"#{dsc_user_suffix_param_name}" => "#{dsc_user_suffix}"}}
+    it 'does not directly contain the user name' do
+      configuration_script_content = ::File.open(dsc_test_resource.command) do | file |
+        file.read
+      end
+      expect(configuration_script_content.include?(dsc_user)).to be(false)
+    end
+    it_behaves_like 'a dsc_script with configuration data'
+  end
+
+  shared_examples_for 'a dsc_script with configuration data that uses environment variables' do
+    let(:dsc_user_code) { dsc_user_env_code }
+
+    it 'does not directly contain the user name' do
+      configuration_script_content = ::File.open(dsc_test_resource.command) do | file |
+        file.read
+      end
+      expect(configuration_script_content.include?(dsc_user)).to be(false)
+    end
+    it_behaves_like 'a dsc_script with configuration data'
+  end
+
+  context 'when supplying configuration through the configuration attribute' do
+    let(:dsc_test_resource) { dsc_resource_from_code }
+    it_behaves_like 'a dsc_script resource with specified PowerShell configuration code'
+  end
+
+  context 'when supplying configuration using the path attribute' do
+    let(:dsc_test_resource) { dsc_resource_from_path }
+    it_behaves_like 'a dsc_script resource with specified PowerShell configuration code'
+  end
+
+  context 'when running a configuration that manages users' do
+    before(:each) do
+      delete_user(dsc_user)
+    end
+
+    let(:dsc_code) { dsc_user_resources_code }
+    let(:config_name_value) { 'DSCTestConfig' }
+    let(:dsc_test_resource) { dsc_resource_from_path }
+
+    it_behaves_like 'a dsc_script with configuration data'
+    it_behaves_like 'a dsc_script with configuration data that uses environment variables'
+    it_behaves_like 'a dsc_script with configuration data that takes parameters'
+    it_behaves_like 'a dsc_script without configuration data that takes parameters'
+  end
+end