chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/unit/resource/conditional_action_not_nothing_spec.rb

@@ -0,0 +1,45 @@
+#
+# Author:: Xabier de Zuazo (<xabier@onddo.com>)
+# Copyright:: Copyright (c) 2013 Onddo Labs, SL.
+# 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::ConditionalActionNotNothing do
+
+  describe "after running a :nothing action" do
+    before do
+      @action = :nothing
+      @conditional = Chef::Resource::ConditionalActionNotNothing.new(@action)
+    end
+
+    it "indicates that resource convergence should not continue" do
+      @conditional.continue?.should be_false
+    end
+  end
+
+  describe "after running an action different to :nothing" do
+    before do
+      @action = :something
+      @conditional = Chef::Resource::ConditionalActionNotNothing.new(@action)
+    end
+
+    it "indicates that resource convergence should continue" do
+      @conditional.continue?.should be_true
+    end
+  end
+
+end

data/spec/unit/resource/execute_spec.rb

@@ -20,105 +20,7 @@
 require 'spec_helper'
 
 describe Chef::Resource::Execute do
-
-  before(:each) do
-    @resource = Chef::Resource::Execute.new("some command")
-  end
-
-  it "should create a new Chef::Resource::Execute" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Execute)
-  end
-
-  it "should set the command to the first argument to new" do
-    @resource.command.should eql("some command")
-  end
-
-  it "should accept an array on instantiation, too" do
-    resource = Chef::Resource::Execute.new(%w{something else})
-    resource.should be_a_kind_of(Chef::Resource)
-    resource.should be_a_kind_of(Chef::Resource::Execute)
-    resource.command.should eql(%w{something else})
-  end
-
-  it "should accept a string for the command to run" do
-    @resource.command "something"
-    @resource.command.should eql("something")
-  end
-
-  it "should accept an array for the command to run" do
-    @resource.command %w{something else}
-    @resource.command.should eql(%w{something else})
-  end
-
-  it "should accept a string for the cwd" do
-    @resource.cwd "something"
-    @resource.cwd.should eql("something")
-  end
-
-  it "should accept a hash for the environment" do
-    test_hash = { :one => :two }
-    @resource.environment(test_hash)
-    @resource.environment.should eql(test_hash)
-  end
-
-  it "allows the environment to be specified with #env" do
-    @resource.should respond_to(:env)
-  end
-
-  it "should accept a string for the group" do
-    @resource.group "something"
-    @resource.group.should eql("something")
-  end
-
-  it "should accept an integer for the group" do
-    @resource.group 1
-    @resource.group.should eql(1)
-  end
-
-  it "should accept an array for the execution path" do
-    @resource.path ["woot"]
-    @resource.path.should eql(["woot"])
-  end
-
-  it "should accept an integer for the return code" do
-    @resource.returns 1
-    @resource.returns.should eql(1)
-  end
-
-  it "should accept an integer for the timeout" do
-    @resource.timeout 1
-    @resource.timeout.should eql(1)
-  end
-
-  it "should accept a string for the user" do
-    @resource.user "something"
-    @resource.user.should eql("something")
-  end
-
-  it "should accept an integer for the user" do
-    @resource.user 1
-    @resource.user.should eql(1)
-  end
-
-  it "should accept a string for creates" do
-    @resource.creates "something"
-    @resource.creates.should eql("something")
-  end
-
-  describe "when it has cwd, environment, group, path, return value, and a user" do
-    before do
-      @resource.command("grep")
-      @resource.cwd("/tmp/")
-      @resource.environment({ :one => :two })
-      @resource.group("legos")
-      @resource.path(["/var/local/"])
-      @resource.returns(1)
-      @resource.user("root")
-    end
-
-    it "returns the command as its identity" do
-      @resource.identity.should == "grep"
-    end
-  end
+  let(:resource_instance_name) { "some command" }
+  let(:execute_resource) { Chef::Resource::Execute.new(resource_instance_name) }
+  it_behaves_like "an execute resource"
 end

data/spec/unit/resource/file_spec.rb

@@ -95,11 +95,6 @@ describe Chef::Resource::File do
       end
     end
 
-    context "on windows", :windows_only do
-      # according to Chef::Resource::File, windows state attributes are rights + deny_rights
-      pending "it describes its state"
-    end
-
     it "returns the file path as its identity" do
       @resource.identity.should == "/tmp/foo.txt"
     end

data/spec/unit/resource/group_spec.rb

@@ -58,6 +58,15 @@ describe Chef::Resource::Group, "initialize" do
       @resource.allowed_actions.detect { |a| a == action.to_sym }.should eql(action.to_sym)
     end
   end
+
+  it "should accept domain groups (@ or \ separator) on non-windows" do
+    lambda { @resource.group_name "domain\@group" }.should_not raise_error(ArgumentError)
+    @resource.group_name.should == "domain\@group"
+    lambda { @resource.group_name "domain\\group" }.should_not raise_error(ArgumentError)
+    @resource.group_name.should == "domain\\group"
+    lambda { @resource.group_name "domain\\group^name" }.should_not raise_error(ArgumentError)
+    @resource.group_name.should == "domain\\group^name"
+  end
 end
 
 describe Chef::Resource::Group, "group_name" do

data/spec/unit/resource/ifconfig_spec.rb

@@ -21,7 +21,10 @@ require 'spec_helper'
 describe Chef::Resource::Ifconfig do
 
   before(:each) do
-    @resource = Chef::Resource::Ifconfig.new("fakey_fakerton")
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @resource = Chef::Resource::Ifconfig.new("fakey_fakerton", @run_context)
   end
 
   describe "when it has target, hardware address, inet address, and a mask" do
@@ -43,4 +46,60 @@ describe Chef::Resource::Ifconfig do
       @resource.identity.should == "charmander"
     end
   end
+
+  shared_examples "being a platform using the default ifconfig provider" do |platform, version|
+    before do
+      @node.automatic_attrs[:platform] = platform
+      @node.automatic_attrs[:platform_version] = version
+    end
+
+    it "should use an ordinary Provider::Ifconfig as a provider for #{platform} #{version}" do
+      @resource.provider_for_action(:add).should be_a_kind_of(Chef::Provider::Ifconfig)
+      @resource.provider_for_action(:add).should_not be_a_kind_of(Chef::Provider::Ifconfig::Debian)
+      @resource.provider_for_action(:add).should_not be_a_kind_of(Chef::Provider::Ifconfig::Redhat)
+    end
+  end
+
+  shared_examples "being a platform based on RedHat" do |platform, version|
+    before do
+      @node.automatic_attrs[:platform] = platform
+      @node.automatic_attrs[:platform_version] = version
+    end
+
+    it "should use an Provider::Ifconfig::Redhat as a provider for #{platform} #{version}" do
+      @resource.provider_for_action(:add).should be_a_kind_of(Chef::Provider::Ifconfig::Redhat)
+    end
+  end
+
+  shared_examples "being a platform based on a recent Debian" do |platform, version|
+    before do
+      @node.automatic_attrs[:platform] = platform
+      @node.automatic_attrs[:platform_version] = version
+    end
+
+    it "should use an Ifconfig::Debian as a provider for #{platform} #{version}" do
+      @resource.provider_for_action(:add).should be_a_kind_of(Chef::Provider::Ifconfig::Debian)
+    end
+  end
+
+  describe "when it is a RedHat platform" do
+    it_should_behave_like "being a platform based on RedHat", "redhat", "4.0"
+  end
+
+  describe "when it is an old Debian platform" do
+    it_should_behave_like "being a platform using the default ifconfig provider", "debian", "6.0"
+  end
+
+  describe "when it is a new Debian platform" do
+    it_should_behave_like "being a platform based on a recent Debian", "debian", "7.0"
+  end
+
+  describe "when it is an old Ubuntu platform" do
+    it_should_behave_like "being a platform using the default ifconfig provider", "ubuntu", "11.04"
+  end
+
+  describe "when it is a new Ubuntu platform" do
+    it_should_behave_like "being a platform based on a recent Debian", "ubuntu", "11.10"
+  end
+
 end

data/spec/unit/resource/link_spec.rb

@@ -22,6 +22,7 @@ require 'spec_helper'
 describe Chef::Resource::Link do
 
   before(:each) do
+    Chef::Resource::Link.any_instance.should_receive(:verify_links_supported!).and_return(true)
     @resource = Chef::Resource::Link.new("fakey_fakerton")
   end
 

data/spec/unit/resource/mount_spec.rb

@@ -82,17 +82,6 @@ describe Chef::Resource::Mount do
     @resource.options.should be_a_kind_of(Array)
   end
 
-  it "should allow options to be sent as a delayed evaluator" do
-    @resource.options Chef::DelayedEvaluator.new {["rw", "noexec"]}
-    @resource.options.should eql(["rw", "noexec"])
-  end
-
-  it "should allow options to be sent as a delayed evaluator, and convert to array" do
-    @resource.options Chef::DelayedEvaluator.new {"rw,noexec"}
-    @resource.options.should be_a_kind_of(Array)
-    @resource.options.should eql(["rw", "noexec"])
-  end
-
   it "should accept true for mounted" do
     @resource.mounted(true) 
     @resource.mounted.should eql(true)
@@ -147,6 +136,21 @@ describe Chef::Resource::Mount do
     @resource.supports.should == support_hash
   end
 
+  it "should allow you to set username" do
+    @resource.username("Administrator")
+    @resource.username.should == "Administrator"
+  end
+
+  it "should allow you to set password" do
+    @resource.password("Jetstream123!")
+    @resource.password.should == "Jetstream123!"
+  end
+
+  it "should allow you to set domain" do
+    @resource.domain("TEST_DOMAIN")
+    @resource.domain.should == "TEST_DOMAIN"
+  end
+
   describe "when it has mount point, device type, and fstype" do
     before do 
       @resource.device("charmander")
@@ -166,4 +170,26 @@ describe Chef::Resource::Mount do
       @resource.identity.should == "charmander"
     end
   end
+
+  describe "when it has username, password and domain" do
+    before do 
+      @resource.mount_point("T:")
+      @resource.device("charmander")
+      @resource.username("Administrator")
+      @resource.password("Jetstream123!")
+      @resource.domain("TEST_DOMAIN")
+    end
+
+    it "describes its state" do
+      state = @resource.state
+      puts state
+      state[:mount_point].should == "T:"
+      state[:username].should == "Administrator"
+      state[:password].should == "Jetstream123!"
+      state[:domain].should == "TEST_DOMAIN"
+      state[:device_type].should eql(:device)
+      state[:fstype].should == "auto"
+    end
+
+  end
 end

data/spec/unit/resource/powershell_spec.rb

@@ -0,0 +1,48 @@
+#
+# Author:: Adam Edwards (<adamed@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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::PowershellScript do
+
+  before(:each) do
+    node = Chef::Node.new
+
+    node.default["kernel"] = Hash.new
+    node.default["kernel"][:machine] = :x86_64.to_s
+
+    run_context = Chef::RunContext.new(node, nil, nil)
+
+    @resource = Chef::Resource::PowershellScript.new("powershell_unit_test", run_context)
+
+  end  
+
+  it "should create a new Chef::Resource::PowershellScript" do
+    @resource.should be_a_kind_of(Chef::Resource::PowershellScript)
+  end
+  
+  context "windowsscript" do
+    let(:resource_instance) { @resource }
+    let(:resource_instance_name ) { @resource.command }
+    let(:resource_name) { :powershell_script }
+    let(:interpreter_file_name) { 'powershell.exe' }
+
+    it_should_behave_like "a Windows script resource"  
+  end
+
+end

data/spec/unit/resource/registry_key_spec.rb

@@ -0,0 +1,171 @@
+#
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2012 OpsCode, 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::RegistryKey, "initialize" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should create a new Chef::Resource::RegistryKey" do
+    @resource.should be_a_kind_of(Chef::Resource)
+    @resource.should be_a_kind_of(Chef::Resource::RegistryKey)
+  end
+
+  it "should set the resource_name to :registry_key" do
+    @resource.resource_name.should eql(:registry_key)
+  end
+
+  it "should set the key equal to the argument to initialize" do
+    @resource.key.should eql('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should default recursive to false" do
+    @resource.recursive.should eql(false)
+  end
+
+  it "should default architecture to :machine" do
+    @resource.architecture.should eql(:machine)
+  end
+
+  it "should set action to :create" do
+    @resource.action.should eql(:create)
+  end
+
+  %w{create create_if_missing delete delete_key}.each do |action|
+    it "should allow action #{action}" do
+      @resource.allowed_actions.detect { |a| a == action.to_sym }.should eql(action.to_sym)
+    end
+  end
+end
+
+describe Chef::Resource::RegistryKey, "key" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should allow a string" do
+    @resource.key 'HKCU\Software\Poosh'
+    @resource.key.should eql('HKCU\Software\Poosh')
+  end
+
+  it "should not allow an integer" do
+    lambda { @resource.send(:key, 100) }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow a hash" do
+    lambda { @resource.send(:key, { :sonic => "screwdriver" }) }.should raise_error(ArgumentError)
+  end
+end
+
+describe Chef::Resource::RegistryKey, "values" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should allow a single proper hash of registry values" do
+    @resource.values( { :name => 'poosh', :type => :string, :data => 'carmen' } )
+    @resource.values.should eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ])
+  end
+
+  it "should allow an array of proper hashes of registry values" do
+    @resource.values [ { :name => 'poosh', :type => :string, :data => 'carmen' } ]
+    @resource.values.should eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ])
+  end
+
+  it "should throw an exception if the name field is missing" do
+    lambda { @resource.values [ { :type => :string, :data => 'carmen' } ] }.should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if the type field is missing" do
+    lambda { @resource.values [ { :name => 'poosh', :data => 'carmen' } ] }.should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if the data field is missing" do
+    lambda { @resource.values [ { :name => 'poosh', :type => :string } ] }.should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if extra fields are present" do
+    lambda { @resource.values [ { :name => 'poosh', :type => :string, :data => 'carmen', :screwdriver => 'sonic' } ] }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow a string" do
+    lambda { @resource.send(:values, 'souffle') }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow an integer" do
+    lambda { @resource.send(:values, 100) }.should raise_error(ArgumentError)
+  end
+end
+
+describe Chef::Resource::RegistryKey, "recursive" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should allow a boolean" do
+    @resource.recursive(true)
+    @resource.recursive.should eql(true)
+  end
+
+  it "should not allow a hash" do
+    lambda { @resource.recursive({:sonic => :screwdriver}) }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow an array" do
+    lambda { @resource.recursive([:nose, :chin]) }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow a string" do
+    lambda { @resource.recursive('souffle') }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow an integer" do
+    lambda { @resource.recursive(100) }.should raise_error(ArgumentError)
+  end
+end
+
+describe Chef::Resource::RegistryKey, "architecture" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  [ :i386, :x86_64, :machine ].each do |arch|
+    it "should allow #{arch} as a symbol" do
+      @resource.architecture(arch)
+      @resource.architecture.should eql(arch)
+    end
+  end
+
+  it "should not allow a hash" do
+    lambda { @resource.architecture({:sonic => :screwdriver}) }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow an array" do
+    lambda { @resource.architecture([:nose, :chin]) }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow a string" do
+    lambda { @resource.architecture('souffle') }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow an integer" do
+    lambda { @resource.architecture(100) }.should raise_error(ArgumentError)
+  end
+end