From 85ad3ee585ab50d173c083325d106967d2161dab Mon Sep 17 00:00:00 2001 From: harikesh-kolekar Date: Mon, 29 Jan 2018 12:55:28 +0000 Subject: rename env resource to windows_env Signed-off-by: harikesh-kolekar --- spec/functional/resource/env_spec.rb | 285 ------------------- spec/functional/resource/windows_env_spec.rb | 285 +++++++++++++++++++ spec/unit/exceptions_spec.rb | 2 +- spec/unit/provider/env/windows_spec.rb | 103 ------- spec/unit/provider/env_spec.rb | 323 --------------------- spec/unit/provider/windows_env_spec.rb | 400 +++++++++++++++++++++++++++ spec/unit/provider_resolver_spec.rb | 2 +- spec/unit/resource/env_spec.rb | 77 ------ spec/unit/resource/windows_env_spec.rb | 85 ++++++ 9 files changed, 772 insertions(+), 790 deletions(-) delete mode 100755 spec/functional/resource/env_spec.rb create mode 100644 spec/functional/resource/windows_env_spec.rb delete mode 100644 spec/unit/provider/env/windows_spec.rb delete mode 100644 spec/unit/provider/env_spec.rb create mode 100644 spec/unit/provider/windows_env_spec.rb delete mode 100644 spec/unit/resource/env_spec.rb create mode 100644 spec/unit/resource/windows_env_spec.rb (limited to 'spec') diff --git a/spec/functional/resource/env_spec.rb b/spec/functional/resource/env_spec.rb deleted file mode 100755 index 4c96b33081..0000000000 --- a/spec/functional/resource/env_spec.rb +++ /dev/null @@ -1,285 +0,0 @@ -# -# Author:: Adam Edwards () -# Copyright:: Copyright 2014-2016, 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" - -describe Chef::Resource::Env, :windows_only do - context "when running on Windows" do - let(:chef_env_test_lower_case) { "chefenvtest" } - let(:chef_env_test_mixed_case) { "chefENVtest" } - let(:chef_env_with_delim) { "chef_env_with_delim" } - let(:chef_env_delim) { ";" } - let(:chef_env_test_delim) { "#{value1};#{value2}" } - let(:env_dne_key) { "env_dne_key" } - let(:env_value1) { "value1" } - let(:env_value2) { "value2" } - let(:delim_value) { "#{env_value1};#{env_value2}" } - let(:env_user) { ENV["USERNAME"].upcase } - let(:default_env_user) { "" } - - let(:env_obj) do - wmi = WmiLite::Wmi.new - environment_variables = wmi.query("select * from Win32_Environment where name = '#{test_resource.key_name}'") - if environment_variables && environment_variables.length > 0 - environment_variables.each do |env| - env_obj = env.wmi_ole_object - return env_obj if env_obj.username.split('\\').last.casecmp(test_resource.user) == 0 - end - end - nil - end - - let(:env_value_expandable) { "%SystemRoot%" } - let(:test_run_context) do - node = Chef::Node.new - node.default["os"] = "windows" - node.default["platform"] = "windows" - node.default["platform_version"] = "6.1" - empty_events = Chef::EventDispatch::Dispatcher.new - Chef::RunContext.new(node, {}, empty_events) - end - let(:test_resource) do - Chef::Resource::Env.new("unknown", test_run_context) - end - - before(:each) do - resource_lower = Chef::Resource::Env.new(chef_env_test_lower_case, test_run_context) - resource_lower.run_action(:delete) - resource_lower = Chef::Resource::Env.new(chef_env_test_lower_case, test_run_context) - resource_lower.user(env_user) - resource_lower.run_action(:delete) - resource_mixed = Chef::Resource::Env.new(chef_env_test_mixed_case, test_run_context) - resource_mixed.run_action(:delete) - resource_mixed = Chef::Resource::Env.new(chef_env_test_mixed_case, test_run_context) - resource_lower.user(env_user) - resource_mixed.run_action(:delete) - end - - context "when the create action is invoked" do - it "should create an environment variable for action create" do - expect(ENV[chef_env_test_lower_case]).to eq(nil) - test_resource.key_name(chef_env_test_lower_case) - test_resource.value(env_value1) - test_resource.run_action(:create) - expect(ENV[chef_env_test_lower_case]).to eq(env_value1) - end - - it "should create an environment variable with default user System for action create" do - expect(ENV[chef_env_test_lower_case]).to eq(nil) - test_resource.key_name(chef_env_test_lower_case) - test_resource.value(env_value1) - test_resource.run_action(:create) - expect(env_obj.username.upcase).to eq(default_env_user) - end - - it "should create an environment variable with user for action create" do - expect(ENV[chef_env_test_lower_case]).to eq(nil) - test_resource.key_name(chef_env_test_lower_case) - test_resource.value(env_value1) - test_resource.user(env_user) - test_resource.run_action(:create) - expect(env_obj.username.split('\\').last.upcase).to eq(env_user) - end - - context "when env variable exist with same name" do - before(:each) do - test_resource.key_name(chef_env_test_lower_case) - test_resource.value(env_value1) - test_resource.run_action(:create) - end - it "should modify an existing variable's value to a new value" do - expect(ENV[chef_env_test_lower_case]).to eq(env_value1) - test_resource.value(env_value2) - test_resource.run_action(:create) - expect(ENV[chef_env_test_lower_case]).to eq(env_value2) - end - - it "should not modify an existing variable's value to a new value if the users are different" do - expect(ENV[chef_env_test_lower_case]).to eq(env_value1) - test_resource.value(env_value2) - test_resource.user(env_user) - test_resource.run_action(:create) - test_resource.key_name(chef_env_test_lower_case) - test_resource.user(default_env_user) - expect(env_obj.variablevalue).to eq(env_value1) - end - - it "should modify an existing variable's value to a new value if the variable name case differs from the existing variable" do - expect(ENV[chef_env_test_lower_case]).to eq(env_value1) - test_resource.key_name(chef_env_test_mixed_case) - test_resource.value(env_value2) - test_resource.run_action(:create) - expect(ENV[chef_env_test_lower_case]).to eq(env_value2) - end - end - - it "should not expand environment variables if the variable is not PATH" do - expect(ENV[chef_env_test_lower_case]).to eq(nil) - test_resource.key_name(chef_env_test_lower_case) - test_resource.value(env_value_expandable) - test_resource.run_action(:create) - expect(ENV[chef_env_test_lower_case]).to eq(env_value_expandable) - end - end - - context "when the modify action is invoked" do - it "should raise an exception for modify if the variable doesn't exist" do - expect(ENV[chef_env_test_lower_case]).to eq(nil) - test_resource.key_name(chef_env_test_lower_case) - test_resource.value(env_value1) - expect { test_resource.run_action(:modify) }.to raise_error(Chef::Exceptions::Env) - end - - context "when env variable exist with same name" do - before(:each) do - test_resource.key_name(chef_env_test_lower_case) - test_resource.value(env_value1) - test_resource.run_action(:create) - end - - it "should modify an existing variable's value to a new value" do - expect(ENV[chef_env_test_lower_case]).to eq(env_value1) - test_resource.value(env_value2) - test_resource.run_action(:modify) - expect(ENV[chef_env_test_lower_case]).to eq(env_value2) - end - - # This examlpe covers Chef Issue #1754 - it "should modify an existing variable's value to a new value if the variable name case differs from the existing variable" do - expect(ENV[chef_env_test_lower_case]).to eq(env_value1) - test_resource.key_name(chef_env_test_mixed_case) - test_resource.value(env_value2) - test_resource.run_action(:modify) - expect(ENV[chef_env_test_lower_case]).to eq(env_value2) - end - - it "should not expand environment variables if the variable is not PATH" do - expect(ENV[chef_env_test_lower_case]).to eq(env_value1) - test_resource.value(env_value_expandable) - test_resource.run_action(:modify) - expect(ENV[chef_env_test_lower_case]).to eq(env_value_expandable) - end - end - - context "when using PATH" do - let(:random_name) { Time.now.to_i } - let(:env_val) { "#{env_value_expandable}_#{random_name}" } - let!(:path_before) { test_resource.provider_for_action(test_resource.action).env_value("PATH") || "" } - let!(:env_path_before) { ENV["PATH"] } - - it "should expand PATH" do - expect(path_before).not_to include(env_val) - test_resource.key_name("PATH") - test_resource.value("#{path_before};#{env_val}") - test_resource.run_action(:create) - expect(ENV["PATH"]).not_to include(env_val) - expect(ENV["PATH"]).to include("#{random_name}") - end - - after(:each) do - # cleanup so we don't flood the path - test_resource.key_name("PATH") - test_resource.value(path_before) - test_resource.run_action(:create) - ENV["PATH"] = env_path_before - end - end - - end - - context "when the delete action is invoked" do - context "when env variable exist with same name" do - before(:each) do - test_resource.key_name(chef_env_test_lower_case) - test_resource.value(env_value1) - test_resource.run_action(:create) - end - - it "should delete a System environment variable" do - expect(ENV[chef_env_test_lower_case]).to eq(env_value1) - test_resource.run_action(:delete) - expect(ENV[chef_env_test_lower_case]).to eq(nil) - end - - it "should not delete an System environment variable if user are passed" do - expect(ENV[chef_env_test_lower_case]).to eq(env_value1) - test_resource.user(env_user) - test_resource.run_action(:delete) - test_resource.user(default_env_user) - expect(env_obj).not_to be_nil - end - end - - context "when env variable exist with same name" do - before(:each) do - test_resource.key_name(chef_env_test_lower_case) - test_resource.value(env_value1) - test_resource.user(env_user) - test_resource.run_action(:create) - end - - it "should delete a user environment variable" do - expect(ENV[chef_env_test_lower_case]).to eq(env_value1) - test_resource.run_action(:delete) - expect(env_obj).to eq(nil) - end - - it "should not delete an user environment variable if user is not passed" do - expect(ENV[chef_env_test_lower_case]).to eq(env_value1) - test_resource.user(default_env_user) - test_resource.run_action(:delete) - test_resource.user(env_user) - expect(env_obj).not_to be_nil - end - end - - context "when env variable exist with same name" do - before(:each) do - test_resource.key_name(chef_env_with_delim) - test_resource.delim(chef_env_delim) - test_resource.value(delim_value) - test_resource.run_action(:create) - end - - it "should not delete variable when a delim present" do - expect(ENV[chef_env_with_delim]).to eq(delim_value) - test_resource.value(env_value1) - test_resource.run_action(:delete) - expect(ENV[chef_env_with_delim]).to eq(env_value2) - end - end - - it "should not raise an exception when a non-existent environment variable is deleted" do - expect(ENV[chef_env_test_lower_case]).to eq(nil) - test_resource.key_name(chef_env_test_lower_case) - test_resource.value(env_value1) - expect { test_resource.run_action(:delete) }.not_to raise_error - expect(ENV[chef_env_test_lower_case]).to eq(nil) - end - - it "should delete a value from the current process even if it is not in the registry" do - expect(ENV[env_dne_key]).to eq(nil) - ENV[env_dne_key] = env_value1 - test_resource.key_name(env_dne_key) - test_resource.run_action(:delete) - expect(ENV[env_dne_key]).to eq(nil) - end - - end - end -end diff --git a/spec/functional/resource/windows_env_spec.rb b/spec/functional/resource/windows_env_spec.rb new file mode 100644 index 0000000000..a6c6b39970 --- /dev/null +++ b/spec/functional/resource/windows_env_spec.rb @@ -0,0 +1,285 @@ +# +# Author:: Adam Edwards () +# Copyright:: Copyright 2014-2016, 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" + +describe Chef::Resource::WindowsEnv, :windows_only do + context "when running on Windows" do + let(:chef_env_test_lower_case) { "chefenvtest" } + let(:chef_env_test_mixed_case) { "chefENVtest" } + let(:chef_env_with_delim) { "chef_env_with_delim" } + let(:chef_env_delim) { ";" } + let(:chef_env_test_delim) { "#{value1};#{value2}" } + let(:env_dne_key) { "env_dne_key" } + let(:env_value1) { "value1" } + let(:env_value2) { "value2" } + let(:delim_value) { "#{env_value1};#{env_value2}" } + let(:env_user) { ENV["USERNAME"].upcase } + let(:default_env_user) { "" } + + let(:env_obj) do + wmi = WmiLite::Wmi.new + environment_variables = wmi.query("select * from Win32_Environment where name = '#{test_resource.key_name}'") + if environment_variables && environment_variables.length > 0 + environment_variables.each do |env| + env_obj = env.wmi_ole_object + return env_obj if env_obj.username.split('\\').last.casecmp(test_resource.user) == 0 + end + end + nil + end + + let(:env_value_expandable) { "%SystemRoot%" } + let(:test_run_context) do + node = Chef::Node.new + node.default["os"] = "windows" + node.default["platform"] = "windows" + node.default["platform_version"] = "6.1" + empty_events = Chef::EventDispatch::Dispatcher.new + Chef::RunContext.new(node, {}, empty_events) + end + let(:test_resource) do + Chef::Resource::WindowsEnv.new("unknown", test_run_context) + end + + before(:each) do + resource_lower = Chef::Resource::WindowsEnv.new(chef_env_test_lower_case, test_run_context) + resource_lower.run_action(:delete) + resource_lower = Chef::Resource::WindowsEnv.new(chef_env_test_lower_case, test_run_context) + resource_lower.user(env_user) + resource_lower.run_action(:delete) + resource_mixed = Chef::Resource::WindowsEnv.new(chef_env_test_mixed_case, test_run_context) + resource_mixed.run_action(:delete) + resource_mixed = Chef::Resource::WindowsEnv.new(chef_env_test_mixed_case, test_run_context) + resource_lower.user(env_user) + resource_mixed.run_action(:delete) + end + + context "when the create action is invoked" do + it "should create an environment variable for action create" do + expect(ENV[chef_env_test_lower_case]).to eq(nil) + test_resource.key_name(chef_env_test_lower_case) + test_resource.value(env_value1) + test_resource.run_action(:create) + expect(ENV[chef_env_test_lower_case]).to eq(env_value1) + end + + it "should create an environment variable with default user System for action create" do + expect(ENV[chef_env_test_lower_case]).to eq(nil) + test_resource.key_name(chef_env_test_lower_case) + test_resource.value(env_value1) + test_resource.run_action(:create) + expect(env_obj.username.upcase).to eq(default_env_user) + end + + it "should create an environment variable with user for action create" do + expect(ENV[chef_env_test_lower_case]).to eq(nil) + test_resource.key_name(chef_env_test_lower_case) + test_resource.value(env_value1) + test_resource.user(env_user) + test_resource.run_action(:create) + expect(env_obj.username.split('\\').last.upcase).to eq(env_user) + end + + context "when env variable exist with same name" do + before(:each) do + test_resource.key_name(chef_env_test_lower_case) + test_resource.value(env_value1) + test_resource.run_action(:create) + end + it "should modify an existing variable's value to a new value" do + expect(ENV[chef_env_test_lower_case]).to eq(env_value1) + test_resource.value(env_value2) + test_resource.run_action(:create) + expect(ENV[chef_env_test_lower_case]).to eq(env_value2) + end + + it "should not modify an existing variable's value to a new value if the users are different" do + expect(ENV[chef_env_test_lower_case]).to eq(env_value1) + test_resource.value(env_value2) + test_resource.user(env_user) + test_resource.run_action(:create) + test_resource.key_name(chef_env_test_lower_case) + test_resource.user(default_env_user) + expect(env_obj.variablevalue).to eq(env_value1) + end + + it "should modify an existing variable's value to a new value if the variable name case differs from the existing variable" do + expect(ENV[chef_env_test_lower_case]).to eq(env_value1) + test_resource.key_name(chef_env_test_mixed_case) + test_resource.value(env_value2) + test_resource.run_action(:create) + expect(ENV[chef_env_test_lower_case]).to eq(env_value2) + end + end + + it "should not expand environment variables if the variable is not PATH" do + expect(ENV[chef_env_test_lower_case]).to eq(nil) + test_resource.key_name(chef_env_test_lower_case) + test_resource.value(env_value_expandable) + test_resource.run_action(:create) + expect(ENV[chef_env_test_lower_case]).to eq(env_value_expandable) + end + end + + context "when the modify action is invoked" do + it "should raise an exception for modify if the variable doesn't exist" do + expect(ENV[chef_env_test_lower_case]).to eq(nil) + test_resource.key_name(chef_env_test_lower_case) + test_resource.value(env_value1) + expect { test_resource.run_action(:modify) }.to raise_error(Chef::Exceptions::WindowsEnv) + end + + context "when env variable exist with same name" do + before(:each) do + test_resource.key_name(chef_env_test_lower_case) + test_resource.value(env_value1) + test_resource.run_action(:create) + end + + it "should modify an existing variable's value to a new value" do + expect(ENV[chef_env_test_lower_case]).to eq(env_value1) + test_resource.value(env_value2) + test_resource.run_action(:modify) + expect(ENV[chef_env_test_lower_case]).to eq(env_value2) + end + + # This examlpe covers Chef Issue #1754 + it "should modify an existing variable's value to a new value if the variable name case differs from the existing variable" do + expect(ENV[chef_env_test_lower_case]).to eq(env_value1) + test_resource.key_name(chef_env_test_mixed_case) + test_resource.value(env_value2) + test_resource.run_action(:modify) + expect(ENV[chef_env_test_lower_case]).to eq(env_value2) + end + + it "should not expand environment variables if the variable is not PATH" do + expect(ENV[chef_env_test_lower_case]).to eq(env_value1) + test_resource.value(env_value_expandable) + test_resource.run_action(:modify) + expect(ENV[chef_env_test_lower_case]).to eq(env_value_expandable) + end + end + + context "when using PATH" do + let(:random_name) { Time.now.to_i } + let(:env_val) { "#{env_value_expandable}_#{random_name}" } + let!(:path_before) { test_resource.provider_for_action(test_resource.action).env_value("PATH") || "" } + let!(:env_path_before) { ENV["PATH"] } + + it "should expand PATH" do + expect(path_before).not_to include(env_val) + test_resource.key_name("PATH") + test_resource.value("#{path_before};#{env_val}") + test_resource.run_action(:create) + expect(ENV["PATH"]).not_to include(env_val) + expect(ENV["PATH"]).to include("#{random_name}") + end + + after(:each) do + # cleanup so we don't flood the path + test_resource.key_name("PATH") + test_resource.value(path_before) + test_resource.run_action(:create) + ENV["PATH"] = env_path_before + end + end + + end + + context "when the delete action is invoked" do + context "when env variable exist with same name" do + before(:each) do + test_resource.key_name(chef_env_test_lower_case) + test_resource.value(env_value1) + test_resource.run_action(:create) + end + + it "should delete a System environment variable" do + expect(ENV[chef_env_test_lower_case]).to eq(env_value1) + test_resource.run_action(:delete) + expect(ENV[chef_env_test_lower_case]).to eq(nil) + end + + it "should not delete an System environment variable if user are passed" do + expect(ENV[chef_env_test_lower_case]).to eq(env_value1) + test_resource.user(env_user) + test_resource.run_action(:delete) + test_resource.user(default_env_user) + expect(env_obj).not_to be_nil + end + end + + context "when env variable exist with same name" do + before(:each) do + test_resource.key_name(chef_env_test_lower_case) + test_resource.value(env_value1) + test_resource.user(env_user) + test_resource.run_action(:create) + end + + it "should delete a user environment variable" do + expect(ENV[chef_env_test_lower_case]).to eq(env_value1) + test_resource.run_action(:delete) + expect(env_obj).to eq(nil) + end + + it "should not delete an user environment variable if user is not passed" do + expect(ENV[chef_env_test_lower_case]).to eq(env_value1) + test_resource.user(default_env_user) + test_resource.run_action(:delete) + test_resource.user(env_user) + expect(env_obj).not_to be_nil + end + end + + context "when env variable exist with same name" do + before(:each) do + test_resource.key_name(chef_env_with_delim) + test_resource.delim(chef_env_delim) + test_resource.value(delim_value) + test_resource.run_action(:create) + end + + it "should not delete variable when a delim present" do + expect(ENV[chef_env_with_delim]).to eq(delim_value) + test_resource.value(env_value1) + test_resource.run_action(:delete) + expect(ENV[chef_env_with_delim]).to eq(env_value2) + end + end + + it "should not raise an exception when a non-existent environment variable is deleted" do + expect(ENV[chef_env_test_lower_case]).to eq(nil) + test_resource.key_name(chef_env_test_lower_case) + test_resource.value(env_value1) + expect { test_resource.run_action(:delete) }.not_to raise_error + expect(ENV[chef_env_test_lower_case]).to eq(nil) + end + + it "should delete a value from the current process even if it is not in the registry" do + expect(ENV[env_dne_key]).to eq(nil) + ENV[env_dne_key] = env_value1 + test_resource.key_name(env_dne_key) + test_resource.run_action(:delete) + expect(ENV[env_dne_key]).to eq(nil) + end + + end + end +end diff --git a/spec/unit/exceptions_spec.rb b/spec/unit/exceptions_spec.rb index e952a5448a..c892b24f28 100644 --- a/spec/unit/exceptions_spec.rb +++ b/spec/unit/exceptions_spec.rb @@ -25,7 +25,7 @@ describe Chef::Exceptions do exception_to_super_class = { Chef::Exceptions::Application => RuntimeError, Chef::Exceptions::Cron => RuntimeError, - Chef::Exceptions::Env => RuntimeError, + Chef::Exceptions::WindowsEnv => RuntimeError, Chef::Exceptions::Exec => RuntimeError, Chef::Exceptions::FileNotFound => RuntimeError, Chef::Exceptions::Package => RuntimeError, diff --git a/spec/unit/provider/env/windows_spec.rb b/spec/unit/provider/env/windows_spec.rb deleted file mode 100644 index 5ddc1d6f91..0000000000 --- a/spec/unit/provider/env/windows_spec.rb +++ /dev/null @@ -1,103 +0,0 @@ -# -# Author:: Sander van Harmelen -# Copyright:: Copyright 2014-2016, 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" - -describe Chef::Provider::Env::Windows, :windows_only do - let(:node) { Chef::Node.new } - let(:events) { Chef::EventDispatch::Dispatcher.new } - let(:run_context) { Chef::RunContext.new(node, {}, events) } - - context "when environment variable is not PATH" do - let(:new_resource) do - new_resource = Chef::Resource::Env.new("CHEF_WINDOWS_ENV_TEST") - new_resource.value("foo") - new_resource - end - let(:provider) do - provider = Chef::Provider::Env::Windows.new(new_resource, run_context) - allow(provider).to receive(:env_obj).and_return(double("null object").as_null_object) - provider - end - - describe "action_create" do - before do - ENV.delete("CHEF_WINDOWS_ENV_TEST") - provider.key_exists = false - end - - it "should update the ruby ENV object when it creates the key" do - provider.action_create - expect(ENV["CHEF_WINDOWS_ENV_TEST"]).to eql("foo") - end - end - - describe "action_modify" do - before do - ENV["CHEF_WINDOWS_ENV_TEST"] = "foo" - end - - it "should update the ruby ENV object when it updates the value" do - expect(provider).to receive(:requires_modify_or_create?).and_return(true) - new_resource.value("foobar") - provider.action_modify - expect(ENV["CHEF_WINDOWS_ENV_TEST"]).to eql("foobar") - end - - describe "action_delete" do - before do - ENV["CHEF_WINDOWS_ENV_TEST"] = "foo" - end - - it "should update the ruby ENV object when it deletes the key" do - provider.action_delete - expect(ENV["CHEF_WINDOWS_ENV_TEST"]).to eql(nil) - end - end - end - end - - context "when environment is PATH" do - describe "for PATH" do - let(:system_root) { "%SystemRoot%" } - let(:system_root_value) { 'D:\Windows' } - let(:new_resource) do - new_resource = Chef::Resource::Env.new("PATH") - new_resource.value(system_root) - new_resource - end - let(:provider) do - provider = Chef::Provider::Env::Windows.new(new_resource, run_context) - allow(provider).to receive(:env_obj).and_return(double("null object").as_null_object) - provider - end - - before do - stub_const("ENV", { "PATH" => "" }) - end - - it "replaces Windows system variables" do - expect(provider).to receive(:requires_modify_or_create?).and_return(true) - expect(provider).to receive(:expand_path).with(system_root).and_return(system_root_value) - provider.action_modify - expect(ENV["PATH"]).to eql(system_root_value) - end - end - - end -end diff --git a/spec/unit/provider/env_spec.rb b/spec/unit/provider/env_spec.rb deleted file mode 100644 index a213c06fe4..0000000000 --- a/spec/unit/provider/env_spec.rb +++ /dev/null @@ -1,323 +0,0 @@ -# -# Author:: Doug MacEachern () -# Copyright:: Copyright 2010-2016, VMware, 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" - -describe Chef::Provider::Env do - - before do - @node = Chef::Node.new - @events = Chef::EventDispatch::Dispatcher.new - @run_context = Chef::RunContext.new(@node, {}, @events) - @new_resource = Chef::Resource::Env.new("FOO") - @new_resource.value("bar") - @new_resource.user("") - @provider = Chef::Provider::Env.new(@new_resource, @run_context) - end - - it "assumes the key_name exists by default" do - expect(@provider.key_exists).to be_truthy - end - - describe "when loading the current status" do - before do - #@current_resource = @new_resource.clone - #Chef::Resource::Env.stub(:new).and_return(@current_resource) - @provider.current_resource = @current_resource - allow(@provider).to receive(:env_value).with("FOO").and_return("bar") - allow(@provider).to receive(:env_key_exists).and_return(true) - end - - it "should create a current resource with the same name as the new resource" do - @provider.load_current_resource - expect(@provider.new_resource.name).to eq("FOO") - end - - it "should create a current resource with the same user as the new resource" do - @provider.load_current_resource - expect(@provider.new_resource.user).to eq("") - end - - it "should set the key_name to the key name of the new resource" do - @provider.load_current_resource - expect(@provider.current_resource.key_name).to eq("FOO") - end - - it "should check if the key_name and user exist" do - expect(@provider).to receive(:env_key_exists).with("FOO").and_return(true) - @provider.load_current_resource - expect(@provider.key_exists).to be_truthy - end - - it "should flip the value of exists if the key does not exist" do - expect(@provider).to receive(:env_key_exists).with("FOO").and_return(false) - @provider.load_current_resource - expect(@provider.key_exists).to be_falsey - end - - it "should return the current resource" do - expect(@provider.load_current_resource).to be_a_kind_of(Chef::Resource::Env) - end - end - - describe "action_create" do - before do - @provider.key_exists = false - allow(@provider).to receive(:create_env).and_return(true) - allow(@provider).to receive(:modify_env).and_return(true) - end - - it "should call create_env if the key does not exist with user" do - expect(@provider).to receive(:create_env).and_return(true) - @provider.action_create - end - - it "should set the new_resources updated flag when it creates the key" do - @provider.action_create - expect(@new_resource).to be_updated - end - - it "should check to see if the values are the same if the key exists" do - @provider.key_exists = true - expect(@provider).to receive(:requires_modify_or_create?).and_return(false) - @provider.action_create - end - - it "should call modify_env if the key exists with provided user and values are not equal" do - @provider.key_exists = true - allow(@provider).to receive(:requires_modify_or_create?).and_return(true) - expect(@provider).to receive(:modify_env).and_return(true) - @provider.action_create - end - - it "should set the new_resources updated flag when it updates an existing value" do - @provider.key_exists = true - allow(@provider).to receive(:requires_modify_or_create?).and_return(true) - allow(@provider).to receive(:modify_env).and_return(true) - @provider.action_create - expect(@new_resource).to be_updated - end - end - - describe "action_delete" do - before(:each) do - @provider.current_resource = @current_resource - @provider.key_exists = false - allow(@provider).to receive(:delete_element).and_return(false) - allow(@provider).to receive(:delete_env).and_return(true) - end - - it "should not call delete_env if the key does not exist" do - expect(@provider).not_to receive(:delete_env) - @provider.action_delete - end - - it "should not call delete_element if the key does not exist" do - expect(@provider).not_to receive(:delete_element) - @provider.action_delete - end - - it "should call delete_env if the key exists" do - @provider.key_exists = true - expect(@provider).to receive(:delete_env) - @provider.action_delete - end - - it "should set the new_resources updated flag to true if the key is deleted" do - @provider.key_exists = true - @provider.action_delete - expect(@new_resource).to be_updated - end - end - - describe "action_modify" do - before(:each) do - @provider.current_resource = @current_resource - @provider.key_exists = true - allow(@provider).to receive(:modify_env).and_return(true) - end - - it "should call modify_group if the key exists and values are not equal" do - expect(@provider).to receive(:requires_modify_or_create?).and_return(true) - expect(@provider).to receive(:modify_env).and_return(true) - @provider.action_modify - end - - it "should call modify_group if the key exists and users are not equal" do - expect(@provider).to receive(:requires_modify_or_create?).and_return(true) - expect(@provider).to receive(:modify_env).and_return(true) - @provider.action_modify - end - - it "should set the new resources updated flag to true if modify_env is called" do - allow(@provider).to receive(:requires_modify_or_create?).and_return(true) - allow(@provider).to receive(:modify_env).and_return(true) - @provider.action_modify - expect(@new_resource).to be_updated - end - - it "should not call modify_env if the key exists with user but the values are equal" do - expect(@provider).to receive(:requires_modify_or_create?).and_return(false) - expect(@provider).not_to receive(:modify_env) - @provider.action_modify - end - - it "should raise a Chef::Exceptions::Env if the key doesn't exist" do - @provider.key_exists = false - expect { @provider.action_modify }.to raise_error(Chef::Exceptions::Env) - end - end - - describe "delete_element" do - before(:each) do - @current_resource = Chef::Resource::Env.new("FOO") - - @new_resource.delim ";" - @new_resource.value "C:/bar/bin" - - @current_resource.user "" - @current_resource.value "C:/foo/bin;C:/bar/bin" - @provider.current_resource = @current_resource - end - - it "should return true if the element is not found" do - @new_resource.value("C:/baz/bin") - expect(@provider.delete_element).to eql(true) - end - - it "should return false if the delim not defined" do - @new_resource.delim(nil) - expect(@provider.delete_element).to eql(false) - end - - it "should return true if the element is deleted" do - @new_resource.value("C:/foo/bin") - expect(@provider).to receive(:create_env) - expect(@provider.delete_element).to eql(true) - expect(@new_resource).to be_updated - end - - context "when new_resource's value contains the delimiter" do - it "should return false if all the elements are deleted" do - # This indicates that the entire key needs to be deleted - @new_resource.value("C:/foo/bin;C:/bar/bin") - expect(@provider.delete_element).to eql(false) - expect(@new_resource).not_to be_updated # This will be updated in action_delete - end - - it "should return true if any, but not all, of the elements are deleted" do - @new_resource.value("C:/foo/bin;C:/notbaz/bin") - expect(@provider).to receive(:create_env) - expect(@provider.delete_element).to eql(true) - expect(@new_resource).to be_updated - end - - it "should return true if none of the elements are deleted" do - @new_resource.value("C:/notfoo/bin;C:/notbaz/bin") - expect(@provider.delete_element).to eql(true) - expect(@new_resource).not_to be_updated - end - end - end - - describe "requires_modify_or_create?" do - before(:each) do - @new_resource.value("C:/bar") - @current_resource = @new_resource.clone - @provider.current_resource = @current_resource - end - - it "should return false if the values are equal" do - expect(@provider.requires_modify_or_create?).to be_falsey - end - - it "should return true if the values not are equal" do - @new_resource.value("C:/elsewhere") - expect(@provider.requires_modify_or_create?).to be_truthy - end - - it "should return false if the current value contains the element" do - @new_resource.delim(";") - @current_resource.value("C:/bar;C:/foo;C:/baz") - - expect(@provider.requires_modify_or_create?).to be_falsey - end - - it "should return true if the current value does not contain the element" do - @new_resource.delim(";") - @current_resource.value("C:/biz;C:/foo/bin;C:/baz") - expect(@provider.requires_modify_or_create?).to be_truthy - end - - context "when new_resource's value contains the delimiter" do - it "should return false if all the current values are contained in specified order" do - @new_resource.value("C:/biz;C:/baz") - @new_resource.delim(";") - @current_resource.value("C:/biz;C:/foo/bin;C:/baz") - expect(@provider.requires_modify_or_create?).to be_falsey - end - - it "should return true if any of the new values are not contained" do - @new_resource.value("C:/biz;C:/baz;C:/bin") - @new_resource.delim(";") - @current_resource.value("C:/biz;C:/foo/bin;C:/baz") - expect(@provider.requires_modify_or_create?).to be_truthy - end - - it "should return true if values are contained in different order" do - @new_resource.value("C:/biz;C:/baz") - @new_resource.delim(";") - @current_resource.value("C:/baz;C:/foo/bin;C:/biz") - expect(@provider.requires_modify_or_create?).to be_truthy - end - end - end - - describe "modify_env" do - before(:each) do - allow(@provider).to receive(:create_env).and_return(true) - @new_resource.delim ";" - - @current_resource = Chef::Resource::Env.new("FOO") - @current_resource.value "C:/foo/bin" - @provider.current_resource = @current_resource - end - - it "should not modify the variable passed to the resource" do - new_value = "C:/bar/bin" - passed_value = new_value.dup - @new_resource.value(passed_value) - @provider.modify_env - expect(passed_value).to eq(new_value) - end - - it "should only add values not already contained" do - @new_resource.value("C:/foo;C:/bar;C:/baz") - @current_resource.value("C:/bar;C:/baz;C:/foo/bar") - @provider.modify_env - expect(@new_resource.value).to eq("C:/foo;C:/bar;C:/baz;C:/foo/bar") - end - - it "should reorder values to keep order which asked" do - @new_resource.value("C:/foo;C:/bar;C:/baz") - @current_resource.value("C:/foo/bar;C:/baz;C:/bar") - @provider.modify_env - expect(@new_resource.value).to eq("C:/foo;C:/bar;C:/baz;C:/foo/bar") - end - end -end diff --git a/spec/unit/provider/windows_env_spec.rb b/spec/unit/provider/windows_env_spec.rb new file mode 100644 index 0000000000..47a06d1d06 --- /dev/null +++ b/spec/unit/provider/windows_env_spec.rb @@ -0,0 +1,400 @@ +# +# Author:: Doug MacEachern () +# Copyright:: Copyright 2010-2016, VMware, 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" + +describe Chef::Provider::WindowsEnv do + + before do + @node = Chef::Node.new + @events = Chef::EventDispatch::Dispatcher.new + @run_context = Chef::RunContext.new(@node, {}, @events) + @new_resource = Chef::Resource::WindowsEnv.new("FOO") + @new_resource.value("bar") + @new_resource.user("") + @provider = Chef::Provider::WindowsEnv.new(@new_resource, @run_context) + end + + it "assumes the key_name exists by default" do + expect(@provider.key_exists).to be_truthy + end + + describe "when loading the current status" do + before do + #@current_resource = @new_resource.clone + #Chef::Resource::Env.stub(:new).and_return(@current_resource) + @provider.current_resource = @current_resource + allow(@provider).to receive(:env_value).with("FOO").and_return("bar") + allow(@provider).to receive(:env_key_exists).and_return(true) + end + + it "should create a current resource with the same name as the new resource" do + @provider.load_current_resource + expect(@provider.new_resource.name).to eq("FOO") + end + + it "should create a current resource with the same user as the new resource" do + @provider.load_current_resource + expect(@provider.new_resource.user).to eq("") + end + + it "should set the key_name to the key name of the new resource" do + @provider.load_current_resource + expect(@provider.current_resource.key_name).to eq("FOO") + end + + it "should check if the key_name and user exist" do + expect(@provider).to receive(:env_key_exists).with("FOO").and_return(true) + @provider.load_current_resource + expect(@provider.key_exists).to be_truthy + end + + it "should flip the value of exists if the key does not exist" do + expect(@provider).to receive(:env_key_exists).with("FOO").and_return(false) + @provider.load_current_resource + expect(@provider.key_exists).to be_falsey + end + + it "should return the current resource" do + expect(@provider.load_current_resource).to be_a_kind_of(Chef::Resource::WindowsEnv) + end + end + + describe "action_create" do + before do + @provider.key_exists = false + allow(@provider).to receive(:create_env).and_return(true) + allow(@provider).to receive(:modify_env).and_return(true) + end + + it "should call create_env if the key does not exist with user" do + expect(@provider).to receive(:create_env).and_return(true) + @provider.action_create + end + + it "should set the new_resources updated flag when it creates the key" do + @provider.action_create + expect(@new_resource).to be_updated + end + + it "should check to see if the values are the same if the key exists" do + @provider.key_exists = true + expect(@provider).to receive(:requires_modify_or_create?).and_return(false) + @provider.action_create + end + + it "should call modify_env if the key exists with provided user and values are not equal" do + @provider.key_exists = true + allow(@provider).to receive(:requires_modify_or_create?).and_return(true) + expect(@provider).to receive(:modify_env).and_return(true) + @provider.action_create + end + + it "should set the new_resources updated flag when it updates an existing value" do + @provider.key_exists = true + allow(@provider).to receive(:requires_modify_or_create?).and_return(true) + allow(@provider).to receive(:modify_env).and_return(true) + @provider.action_create + expect(@new_resource).to be_updated + end + end + + describe "action_delete" do + before(:each) do + @provider.current_resource = @current_resource + @provider.key_exists = false + allow(@provider).to receive(:delete_element).and_return(false) + allow(@provider).to receive(:delete_env).and_return(true) + end + + it "should not call delete_env if the key does not exist" do + expect(@provider).not_to receive(:delete_env) + @provider.action_delete + end + + it "should not call delete_element if the key does not exist" do + expect(@provider).not_to receive(:delete_element) + @provider.action_delete + end + + it "should call delete_env if the key exists" do + @provider.key_exists = true + expect(@provider).to receive(:delete_env) + @provider.action_delete + end + + it "should set the new_resources updated flag to true if the key is deleted" do + @provider.key_exists = true + @provider.action_delete + expect(@new_resource).to be_updated + end + end + + describe "action_modify" do + before(:each) do + @provider.current_resource = @current_resource + @provider.key_exists = true + allow(@provider).to receive(:modify_env).and_return(true) + end + + it "should call modify_group if the key exists and values are not equal" do + expect(@provider).to receive(:requires_modify_or_create?).and_return(true) + expect(@provider).to receive(:modify_env).and_return(true) + @provider.action_modify + end + + it "should call modify_group if the key exists and users are not equal" do + expect(@provider).to receive(:requires_modify_or_create?).and_return(true) + expect(@provider).to receive(:modify_env).and_return(true) + @provider.action_modify + end + + it "should set the new resources updated flag to true if modify_env is called" do + allow(@provider).to receive(:requires_modify_or_create?).and_return(true) + allow(@provider).to receive(:modify_env).and_return(true) + @provider.action_modify + expect(@new_resource).to be_updated + end + + it "should not call modify_env if the key exists with user but the values are equal" do + expect(@provider).to receive(:requires_modify_or_create?).and_return(false) + expect(@provider).not_to receive(:modify_env) + @provider.action_modify + end + + it "should raise a Chef::Exceptions::WindowsEnv if the key doesn't exist" do + @provider.key_exists = false + expect { @provider.action_modify }.to raise_error(Chef::Exceptions::WindowsEnv) + end + end + + describe "delete_element" do + before(:each) do + @current_resource = Chef::Resource::WindowsEnv.new("FOO") + + @new_resource.delim ";" + @new_resource.value "C:/bar/bin" + + @current_resource.user "" + @current_resource.value "C:/foo/bin;C:/bar/bin" + @provider.current_resource = @current_resource + end + + it "should return true if the element is not found" do + @new_resource.value("C:/baz/bin") + expect(@provider.delete_element).to eql(true) + end + + it "should return false if the delim not defined" do + @new_resource.delim(nil) + expect(@provider.delete_element).to eql(false) + end + + it "should return true if the element is deleted" do + @new_resource.value("C:/foo/bin") + expect(@provider).to receive(:create_env) + expect(@provider.delete_element).to eql(true) + expect(@new_resource).to be_updated + end + + context "when new_resource's value contains the delimiter" do + it "should return false if all the elements are deleted" do + # This indicates that the entire key needs to be deleted + @new_resource.value("C:/foo/bin;C:/bar/bin") + expect(@provider.delete_element).to eql(false) + expect(@new_resource).not_to be_updated # This will be updated in action_delete + end + + it "should return true if any, but not all, of the elements are deleted" do + @new_resource.value("C:/foo/bin;C:/notbaz/bin") + expect(@provider).to receive(:create_env) + expect(@provider.delete_element).to eql(true) + expect(@new_resource).to be_updated + end + + it "should return true if none of the elements are deleted" do + @new_resource.value("C:/notfoo/bin;C:/notbaz/bin") + expect(@provider.delete_element).to eql(true) + expect(@new_resource).not_to be_updated + end + end + end + + describe "requires_modify_or_create?" do + before(:each) do + @new_resource.value("C:/bar") + @current_resource = @new_resource.clone + @provider.current_resource = @current_resource + end + + it "should return false if the values are equal" do + expect(@provider.requires_modify_or_create?).to be_falsey + end + + it "should return true if the values not are equal" do + @new_resource.value("C:/elsewhere") + expect(@provider.requires_modify_or_create?).to be_truthy + end + + it "should return false if the current value contains the element" do + @new_resource.delim(";") + @current_resource.value("C:/bar;C:/foo;C:/baz") + + expect(@provider.requires_modify_or_create?).to be_falsey + end + + it "should return true if the current value does not contain the element" do + @new_resource.delim(";") + @current_resource.value("C:/biz;C:/foo/bin;C:/baz") + expect(@provider.requires_modify_or_create?).to be_truthy + end + + context "when new_resource's value contains the delimiter" do + it "should return false if all the current values are contained in specified order" do + @new_resource.value("C:/biz;C:/baz") + @new_resource.delim(";") + @current_resource.value("C:/biz;C:/foo/bin;C:/baz") + expect(@provider.requires_modify_or_create?).to be_falsey + end + + it "should return true if any of the new values are not contained" do + @new_resource.value("C:/biz;C:/baz;C:/bin") + @new_resource.delim(";") + @current_resource.value("C:/biz;C:/foo/bin;C:/baz") + expect(@provider.requires_modify_or_create?).to be_truthy + end + + it "should return true if values are contained in different order" do + @new_resource.value("C:/biz;C:/baz") + @new_resource.delim(";") + @current_resource.value("C:/baz;C:/foo/bin;C:/biz") + expect(@provider.requires_modify_or_create?).to be_truthy + end + end + end + + describe "modify_env" do + before(:each) do + allow(@provider).to receive(:create_env).and_return(true) + @new_resource.delim ";" + + @current_resource = Chef::Resource::WindowsEnv.new("FOO") + @current_resource.value "C:/foo/bin" + @provider.current_resource = @current_resource + end + + it "should not modify the variable passed to the resource" do + new_value = "C:/bar/bin" + passed_value = new_value.dup + @new_resource.value(passed_value) + @provider.modify_env + expect(passed_value).to eq(new_value) + end + + it "should only add values not already contained" do + @new_resource.value("C:/foo;C:/bar;C:/baz") + @current_resource.value("C:/bar;C:/baz;C:/foo/bar") + @provider.modify_env + expect(@new_resource.value).to eq("C:/foo;C:/bar;C:/baz;C:/foo/bar") + end + + it "should reorder values to keep order which asked" do + @new_resource.value("C:/foo;C:/bar;C:/baz") + @current_resource.value("C:/foo/bar;C:/baz;C:/bar") + @provider.modify_env + expect(@new_resource.value).to eq("C:/foo;C:/bar;C:/baz;C:/foo/bar") + end + end + + context "when environment variable is not PATH" do + let(:new_resource) do + new_resource = Chef::Resource::WindowsEnv.new("CHEF_WINDOWS_ENV_TEST") + new_resource.value("foo") + new_resource + end + let(:provider) do + provider = Chef::Provider::WindowsEnv::Windows.new(new_resource, run_context) + allow(provider).to receive(:env_obj).and_return(double("null object").as_null_object) + provider + end + + describe "action_create" do + before do + ENV.delete("CHEF_WINDOWS_ENV_TEST") + provider.key_exists = false + end + + it "should update the ruby ENV object when it creates the key" do + provider.action_create + expect(ENV["CHEF_WINDOWS_ENV_TEST"]).to eql("foo") + end + end + + describe "action_modify" do + before do + ENV["CHEF_WINDOWS_ENV_TEST"] = "foo" + end + + it "should update the ruby ENV object when it updates the value" do + expect(provider).to receive(:requires_modify_or_create?).and_return(true) + new_resource.value("foobar") + provider.action_modify + expect(ENV["CHEF_WINDOWS_ENV_TEST"]).to eql("foobar") + end + + describe "action_delete" do + before do + ENV["CHEF_WINDOWS_ENV_TEST"] = "foo" + end + + it "should update the ruby ENV object when it deletes the key" do + provider.action_delete + expect(ENV["CHEF_WINDOWS_ENV_TEST"]).to eql(nil) + end + end + end + end + + context "when environment is PATH" do + describe "for PATH" do + let(:system_root) { "%SystemRoot%" } + let(:system_root_value) { 'D:\Windows' } + let(:new_resource) do + new_resource = Chef::Resource::WindowsEnv.new("PATH") + new_resource.value(system_root) + new_resource + end + let(:provider) do + provider = Chef::Provider::WindowsEnv::Windows.new(new_resource, run_context) + allow(provider).to receive(:env_obj).and_return(double("null object").as_null_object) + provider + end + + before do + stub_const("ENV", { "PATH" => "" }) + end + + it "replaces Windows system variables" do + expect(provider).to receive(:requires_modify_or_create?).and_return(true) + expect(provider).to receive(:expand_path).with(system_root).and_return(system_root_value) + provider.action_modify + expect(ENV["PATH"]).to eql(system_root_value) + end + end + end +end diff --git a/spec/unit/provider_resolver_spec.rb b/spec/unit/provider_resolver_spec.rb index a331093055..9470bca929 100644 --- a/spec/unit/provider_resolver_spec.rb +++ b/spec/unit/provider_resolver_spec.rb @@ -762,7 +762,7 @@ describe Chef::ProviderResolver do "windows" => { batch: [ Chef::Resource::Batch, Chef::Provider::Batch ], dsc_script: [ Chef::Resource::DscScript, Chef::Provider::DscScript ], - env: [ Chef::Resource::Env, Chef::Provider::Env::Windows ], + windows_env: [ Chef::Resource::WindowsEnv, Chef::Provider::WindowsEnv::Windows ], group: [ Chef::Resource::Group, Chef::Provider::Group::Windows ], mount: [ Chef::Resource::Mount, Chef::Provider::Mount::Windows ], package: [ Chef::Resource::WindowsPackage, Chef::Provider::Package::Windows ], diff --git a/spec/unit/resource/env_spec.rb b/spec/unit/resource/env_spec.rb deleted file mode 100644 index 61c40e33e8..0000000000 --- a/spec/unit/resource/env_spec.rb +++ /dev/null @@ -1,77 +0,0 @@ -# -# Author:: Doug MacEachern () -# Author:: Tyler Cloke () -# Copyright:: Copyright 2010-2016, VMware, 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" - -describe Chef::Resource::Env do - let(:resource) { Chef::Resource::Env.new("FOO") } - - it "has a name property" do - expect(resource.name).to eql("FOO") - end - - it "has a default action of 'create'" do - expect(resource.action).to eql([:create]) - end - - { :create => false, :delete => false, :modify => false, :flibber => true }.each do |action, bad_value| - it "should #{bad_value ? 'not' : ''} accept #{action}" do - if bad_value - expect { resource.action action }.to raise_error(ArgumentError) - else - expect { resource.action action }.not_to raise_error - end - end - end - - it "uses the object name as the key_name by default" do - expect(resource.key_name).to eql("FOO") - end - - it "accepts a string as the env value via 'value'" do - expect { resource.value "bar" }.not_to raise_error - end - - it "does not accept a Hash for the env value via 'to'" do - expect { resource.value Hash.new }.to raise_error(ArgumentError) - end - - it "allows you to set an env value via 'to'" do - resource.value "bar" - expect(resource.value).to eql("bar") - end - - describe "when it has key name and value" do - before do - resource.key_name("charmander") - resource.value("level7") - resource.delim("hi") - end - - it "describes its state" do - state = resource.state_for_resource_reporter - expect(state[:value]).to eq("level7") - end - - it "returns the key name as its identity" do - expect(resource.identity).to eq("charmander") - end - end - -end diff --git a/spec/unit/resource/windows_env_spec.rb b/spec/unit/resource/windows_env_spec.rb new file mode 100644 index 0000000000..b1052f045a --- /dev/null +++ b/spec/unit/resource/windows_env_spec.rb @@ -0,0 +1,85 @@ +# +# Author:: Doug MacEachern () +# Author:: Tyler Cloke () +# Copyright:: Copyright 2010-2016, VMware, 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" + +describe Chef::Resource::WindowsEnv do + + before(:each) do + @resource = Chef::Resource::WindowsEnv.new("FOO") + end + + it "creates a new Chef::Resource::WindowsEnv" do + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::WindowsEnv) + end + + it "has a name" do + expect(@resource.name).to eql("FOO") + end + + it "has a default action of 'create'" do + expect(resource.action).to eql([:create]) + end + + { :create => false, :delete => false, :modify => false, :flibber => true }.each do |action, bad_value| + it "should #{bad_value ? 'not' : ''} accept #{action}" do + if bad_value + expect { resource.action action }.to raise_error(ArgumentError) + else + expect { resource.action action }.not_to raise_error + end + end + end + + it "uses the object name as the key_name by default" do + expect(resource.key_name).to eql("FOO") + end + + it "accepts a string as the env value via 'value'" do + expect { resource.value "bar" }.not_to raise_error + end + + it "does not accept a Hash for the env value via 'to'" do + expect { resource.value Hash.new }.to raise_error(ArgumentError) + end + + it "allows you to set an env value via 'to'" do + resource.value "bar" + expect(resource.value).to eql("bar") + end + + describe "when it has key name and value" do + before do + resource.key_name("charmander") + resource.value("level7") + resource.delim("hi") + end + + it "describes its state" do + state = resource.state_for_resource_reporter + expect(state[:value]).to eq("level7") + end + + it "returns the key name as its identity" do + expect(resource.identity).to eq("charmander") + end + end + +end -- cgit v1.2.1