chef 11.4.4 → 11.6.0.hotfix.1

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

@@ -136,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")
@@ -155,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/remote_file_spec.rb

@@ -42,7 +42,7 @@ describe Chef::Resource::RemoteFile do
 
   describe "source" do
     it "does not have a default value for 'source'" do
-      @resource.source.should be_nil
+      @resource.source.should eql([])
     end
 
     it "should accept a URI for the remote file source" do
@@ -64,7 +64,7 @@ describe Chef::Resource::RemoteFile do
       lambda { @resource.source("not-a-uri") }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI)
     end
 
-    it "should raise and exception when source is an empty array" do
+    it "should raise an exception when source is an empty array" do
       lambda { @resource.source([]) }.should raise_error(ArgumentError)
     end
 
@@ -80,7 +80,48 @@ describe Chef::Resource::RemoteFile do
       @resource.checksum.should == nil
     end
   end
-  
+
+  describe "ftp_active_mode" do
+    it "should accept a boolean for the ftp_active_mode object" do
+      @resource.ftp_active_mode true
+      @resource.ftp_active_mode.should be_true
+    end
+
+    it "should default to false" do
+      @resource.ftp_active_mode.should be_false
+    end
+  end
+
+  describe "conditional get options" do
+    it "defaults to using etags and last modified" do
+      @resource.use_etags.should be_true
+      @resource.use_last_modified.should be_true
+    end
+
+    it "enable or disables etag and last modified options as a group" do
+      @resource.use_conditional_get(false)
+      @resource.use_etags.should be_false
+      @resource.use_last_modified.should be_false
+
+      @resource.use_conditional_get(true)
+      @resource.use_etags.should be_true
+      @resource.use_last_modified.should be_true
+    end
+
+    it "disables etags indivdually" do
+      @resource.use_etags(false)
+      @resource.use_etags.should be_false
+      @resource.use_last_modified.should be_true
+    end
+
+    it "disables last modified individually" do
+      @resource.use_last_modified(false)
+      @resource.use_last_modified.should be_false
+      @resource.use_etags.should be_true
+    end
+
+  end
+
   describe "when it has group, mode, owner, source, and checksum" do
     before do 
       if Chef::Platform.windows?
@@ -119,5 +160,4 @@ describe Chef::Resource::RemoteFile do
       end
     end
   end
- 
 end

data/spec/unit/resource/route_spec.rb

@@ -35,7 +35,7 @@ describe Chef::Resource::Route do
   end
   
   it "should have a default action of 'add'" do
-    @resource.action.should eql(:add)
+    @resource.action.should eql([:add])
   end
   
   it "should accept add or delete for action" do

data/spec/unit/resource/script_spec.rb

@@ -20,50 +20,27 @@
 require 'spec_helper'
 
 describe Chef::Resource::Script do
+  let(:resource_instance_name) { "fakey_fakerton" }  
+  let(:script_resource) { Chef::Resource::Script.new(resource_instance_name) }
+  let(:resource_name) { :script }
 
-  before(:each) do
-    @resource = Chef::Resource::Script.new("fakey_fakerton")
-  end  
-
-  it "should create a new Chef::Resource::Script" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Script)
-  end
-  
-  it "should have a resource name of :script" do
-    @resource.resource_name.should eql(:script)
-  end
-  
-  it "should set command to the argument provided to new" do
-    @resource.command.should eql("fakey_fakerton")
-  end
-  
-  it "should accept a string for the code" do
-    @resource.code "hey jude"
-    @resource.code.should eql("hey jude")
-  end
-  
   it "should accept a string for the interpreter" do
-    @resource.interpreter "naaaaNaNaNaaNaaNaaNaa"
-    @resource.interpreter.should eql("naaaaNaNaNaaNaaNaaNaa")
-  end
-
-  it "should accept a string for the flags" do
-    @resource.flags "-f"
-    @resource.flags.should eql("-f")
+    script_resource.interpreter "naaaaNaNaNaaNaaNaaNaa"
+    script_resource.interpreter.should eql("naaaaNaNaNaaNaaNaaNaa")
   end
 
   describe "when it has interpreter and flags" do
     before do 
-      @resource.command("grep")
-      @resource.interpreter("gcc")
-      @resource.flags("-al")
+      script_resource.command("grep")
+      script_resource.interpreter("gcc")
+      script_resource.flags("-al")
     end
 
-    it "returns the command as its identity" do
-      @resource.identity.should == "grep"
+   it "returns the command as its identity" do
+      script_resource.identity.should == "grep"
     end
   end
-
-
+  
+  it_behaves_like "a script resource"
 end
+