chef 11.8.4.ohai7.0-x86-mingw32 → 11.10.0.alpha.1-x86-mingw32

data/spec/unit/config_spec.rb

@@ -360,4 +360,24 @@ describe Chef::Config do
       expect{Chef::Config.log_location = missing_path}.to raise_error Chef::Exceptions::ConfigurationError
     end
   end
+
+  describe "Chef::Config[:event_handlers]" do
+    it "sets a event_handlers to an empty array by default" do
+      Chef::Config[:event_handlers].should eq([])
+    end
+    it "should be able to add custom handlers" do
+      o = Object.new
+      Chef::Config[:event_handlers] << o
+      Chef::Config[:event_handlers].should be_include(o)
+    end
+  end
+
+  describe "Chef::Config[:user_valid_regex]" do
+    context "on a platform that is not Windows" do
+      it "allows one letter usernames" do
+        any_match = Chef::Config[:user_valid_regex].any? { |regex| regex.match('a') }
+        expect(any_match).to be_true
+      end
+    end
+  end
 end

data/spec/unit/encrypted_data_bag_item_spec.rb

@@ -283,35 +283,49 @@ describe Chef::EncryptedDataBagItem do
   end
 
   describe ".load_secret" do
-    subject(:loaded_secret) { Chef::EncryptedDataBagItem.load_secret(path) }
-    let(:path) { "/var/mysecret" }
     let(:secret) { "opensesame" }
-    let(:stubbed_path) { path }
-    before do
-      ::File.stub(:exist?).with(stubbed_path).and_return(true)
-      IO.stub(:read).with(stubbed_path).and_return(secret)
-      Kernel.stub(:open).with(path).and_return(StringIO.new(secret))
+
+    context "when /var/mysecret exists" do
+      before do
+        ::File.stub(:exist?).with("/var/mysecret").and_return(true)
+        IO.stub(:read).with("/var/mysecret").and_return(secret)
+      end
+
+      it "load_secret('/var/mysecret') reads the secret" do
+        Chef::EncryptedDataBagItem.load_secret("/var/mysecret").should eq secret
+      end
     end
 
-    it "reads from a specified path" do
-      loaded_secret.should eq secret
+    context "when /etc/chef/encrypted_data_bag_secret exists" do
+      before do
+        path = Chef::Config.platform_specific_path("/etc/chef/encrypted_data_bag_secret")
+        ::File.stub(:exist?).with(path).and_return(true)
+        IO.stub(:read).with(path).and_return(secret)
+      end
+
+      it "load_secret(nil) reads the secret" do
+        Chef::EncryptedDataBagItem.load_secret(nil).should eq secret
+      end
     end
 
-    context "path argument is nil" do
-      let(:path) { nil }
-      let(:stubbed_path) { "/etc/chef/encrypted_data_bag_secret" }
+    context "when /etc/chef/encrypted_data_bag_secret does not exist" do
+      before do
+        path = Chef::Config.platform_specific_path("/etc/chef/encrypted_data_bag_secret")
+        ::File.stub(:exist?).with(path).and_return(false)
+      end
 
-      it "reads from Chef::Config[:encrypted_data_bag_secret]" do
-        Chef::Config[:encrypted_data_bag_secret] = stubbed_path
-        loaded_secret.should eq secret
+      it "load_secret(nil) emits a reasonable error message" do
+        lambda { Chef::EncryptedDataBagItem.load_secret(nil) }.should raise_error(ArgumentError, "No secret specified to load_secret and no secret found at #{Chef::Config.platform_specific_path('/etc/chef/encrypted_data_bag_secret')}")
       end
     end
 
     context "path argument is a URL" do
-      let(:path) { "http://www.opscode.com/" }
+      before do
+        Kernel.stub(:open).with("http://www.opscode.com/").and_return(StringIO.new(secret))
+      end
 
-      it "reads the URL" do
-        loaded_secret.should eq secret
+      it "reads from the URL" do
+        Chef::EncryptedDataBagItem.load_secret("http://www.opscode.com/").should eq secret
       end
     end
   end

data/spec/unit/knife/cookbook_upload_spec.rb

@@ -40,6 +40,20 @@ describe Chef::Knife::CookbookUpload do
     @knife.ui.stub!(:stderr).and_return(@output)
   end
 
+  describe 'with --concurrency' do
+    it 'should upload cookbooks with predefined concurrency' do
+      @cookbook_uploader = stub(:upload_cookbooks => nil)
+      Chef::CookbookVersion.stub(:list_all_versions).and_return({})
+      @knife.config[:concurrency] = 3
+      @test_cookbook = Chef::CookbookVersion.new('test_cookbook')
+      @cookbook_loader.stub!(:each).and_yield("test_cookbook", @test_cookbook)
+      @cookbook_loader.stub!(:cookbook_names).and_return(["test_cookbook"])
+      Chef::CookbookUploader.should_receive(:new).with( kind_of(Array),  kind_of(Array),
+        {:force=>nil, :concurrency => 3}).and_return(double("Chef::CookbookUploader", :upload_cookbooks=> true))
+      @knife.run
+    end
+  end
+
   describe 'run' do
     before(:each) do
       @cookbook_uploader = stub(:upload_cookbooks => nil)

data/spec/unit/knife/core/subcommand_loader_spec.rb

@@ -45,10 +45,10 @@ describe Chef::Knife::SubcommandLoader do
     ]
     $LOAD_PATH.should_receive(:map).and_return([])
     if Gem::Specification.respond_to? :latest_specs
-      Gem::Specification.should_receive(:latest_specs).and_return(gems)
+      Gem::Specification.should_receive(:latest_specs).with(true).and_return(gems)
       gems[0].should_receive(:matches_for_glob).with(/chef\/knife\/\*\.rb{(.*),\.rb,(.*)}/).and_return(gem_files)
     else
-      Gem.source_index.should_receive(:latest_specs).and_return(gems)
+      Gem.source_index.should_receive(:latest_specs).with(true).and_return(gems)
       gems[0].should_receive(:require_paths).twice.and_return(['lib'])
       gems[0].should_receive(:full_gem_path).and_return('/usr/lib/ruby/gems/knife-ec2-0.5.12')
       Dir.should_receive(:[]).with('/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/*.rb').and_return(gem_files)

data/spec/unit/knife/data_bag_create_spec.rb

@@ -53,6 +53,13 @@ describe Chef::Knife::DataBagCreate do
     @knife.run
   end
 
+  it "tries to create a data bag with an invalid name when given one argument" do
+    @knife.name_args = ['invalid&char']
+    @knife.should_receive(:exit).with(1)
+
+    @knife.run
+  end
+
   it "creates a data bag item when given two arguments" do
     @knife.name_args = ['sudoing_admins', 'ME']
     user_supplied_hash = {"login_name" => "alphaomega", "id" => "ME"}

data/spec/unit/knife/environment_compare_spec.rb

@@ -0,0 +1,112 @@
+#
+# Author:: Sander Botman (<sbotman@schubergphilis.com>)
+# Copyright:: Copyright (c) 2013 Sander Botman.
+# 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::Knife::EnvironmentCompare do
+  before(:each) do
+    @knife = Chef::Knife::EnvironmentCompare.new
+    
+    @environments = {
+      "cita" => "http://localhost:4000/environments/cita",
+      "citm" => "http://localhost:4000/environments/citm"
+    }
+
+    @knife.stub(:environment_list).and_return(@environments)
+
+    @constraints = {
+      "cita" => { "foo" => "= 1.0.1", "bar" => "= 0.0.4" },
+      "citm" => { "foo" => "= 1.0.1", "bar" => "= 0.0.2" }
+    }
+ 
+    @knife.stub(:constraint_list).and_return(@constraints)
+
+    @cookbooks = { "foo"=>"= 1.0.1", "bar"=>"= 0.0.1" } 
+
+    @knife.stub(:cookbook_list).and_return(@cookbooks)
+
+    @rest_double = double('rest')
+    @knife.stub(:rest).and_return(@rest_double)
+    @cookbook_names = ['apache2', 'mysql', 'foo', 'bar', 'dummy', 'chef_handler']
+    @base_url = 'https://server.example.com/cookbooks'
+    @cookbook_data = {}
+    @cookbook_names.each do |item|
+      @cookbook_data[item] = {'url' => "#{@base_url}/#{item}",
+                              'versions' => [{'version' => '1.0.1',
+                                              'url' => "#{@base_url}/#{item}/1.0.1"}]}
+    end 
+
+    @rest_double.stub(:get_rest).with("/cookbooks?num_versions=1").and_return(@cookbook_data)
+
+    @stdout = StringIO.new
+    @knife.ui.stub(:stdout).and_return(@stdout)
+  end
+
+  describe 'run' do
+    it 'should display only cookbooks with version constraints' do
+      @knife.config[:format] = 'summary'
+      @knife.run
+      @environments.each do |item, url|
+        @stdout.string.should match /#{item}/ and @stdout.string.lines.count.should be 4
+      end
+    end
+ 
+    it 'should display 4 number of lines' do
+      @knife.config[:format] = 'summary'
+      @knife.run
+      @stdout.string.lines.count.should be 4
+    end
+  end
+
+  describe 'with -m or --mismatch' do
+    it 'should display only cookbooks that have mismatching version constraints' do
+      @knife.config[:format] = 'summary'
+      @knife.config[:mismatch] = true
+      @knife.run
+      @constraints.each do |item, ver|
+        @stdout.string.should match /#{ver[1]}/
+      end
+    end
+
+    it 'should display 3 number of lines' do
+      @knife.config[:format] = 'summary'
+      @knife.config[:mismatch] = true
+      @knife.run
+      @stdout.string.lines.count.should be 3
+    end
+  end
+ 
+  describe 'with -a or --all' do
+    it 'should display all cookbooks' do
+      @knife.config[:format] = 'summary'
+      @knife.config[:all] = true
+      @knife.run
+      @constraints.each do |item, ver|
+        @stdout.string.should match /#{ver[1]}/
+      end
+    end
+
+    it 'should display 8 number of lines' do
+      @knife.config[:format] = 'summary'
+      @knife.config[:all] = true
+      @knife.run
+      @stdout.string.lines.count.should be 8
+    end
+  end
+
+end

data/spec/unit/knife_spec.rb

@@ -46,7 +46,12 @@ describe Chef::Knife do
         Chef::Knife.reset_config_path!
         # pwd according to your shell is /home/someuser/prod/chef-repo, but
         # chef-repo is a symlink to /home/someuser/codes/chef-repo
-        ENV.stub!(:[]).with("PWD").and_return("/home/someuser/prod/chef-repo")
+        if Chef::Platform.windows?
+          ENV.should_receive(:[]).with("CD").and_return("/home/someuser/prod/chef-repo")
+        else
+          ENV.should_receive(:[]).with("PWD").and_return("/home/someuser/prod/chef-repo")
+        end
+
         Dir.stub!(:pwd).and_return("/home/someuser/codes/chef-repo")
       end
 

data/spec/unit/monkey_patches/uri_spec.rb

@@ -0,0 +1,34 @@
+#--
+# Author:: Daniel DeLeo (<dan@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 URI do
+
+  describe "when a URI contains an IPv6 literal" do
+
+    let(:ipv6_uri) do
+      URI.parse("https://[2a00:1450:4009:809::1008]:8443")
+    end
+
+    it "returns the hostname without brackets" do
+      ipv6_uri.hostname.should == "2a00:1450:4009:809::1008"
+    end
+
+  end
+
+end

data/spec/unit/provider/cookbook_file_spec.rb

@@ -37,7 +37,7 @@ describe Chef::Provider::CookbookFile do
 
   let(:provider) do
     provider = described_class.new(resource, run_context)
-    provider.stub!(:content).and_return(content)
+    provider.stub(:content).and_return(content)
     provider
   end
 
@@ -54,4 +54,5 @@ describe Chef::Provider::CookbookFile do
 
   it_behaves_like Chef::Provider::File
 
+  it_behaves_like "a file provider with source field"
 end

data/spec/unit/provider/cron_spec.rb

@@ -291,6 +291,12 @@ CRONTAB
       @provider.cron_different?.should eql(true)
     end
 
+    it "should return true if mailto doesn't match" do
+      @current_resource.mailto "foo@bar.com"
+      @new_resource.mailto(nil)
+      @provider.cron_different?.should eql(true)
+    end
+
     it "should return false if the objects are identical" do
       @provider.cron_different?.should == false
     end

data/spec/unit/provider/file_spec.rb

@@ -46,10 +46,12 @@ describe Chef::Provider::File do
 
   let(:provider) do
     provider = described_class.new(resource, run_context)
-    provider.stub!(:content).and_return(content)
+    provider.stub(:content).and_return(content)
     provider
   end
 
   it_behaves_like Chef::Provider::File
+
+  it_behaves_like "a file provider with content field"
 end
 

data/spec/unit/provider/git_spec.rb

@@ -172,13 +172,14 @@ SHAS
     let(:default_options) do
       {
         :user => deploy_user,
-        :environment => { "GIT_SSH" => wrapper },
+        :environment => { "GIT_SSH" => wrapper, "HOME" => "/home/deployNinja" },
         :log_tag => "git[web2.0 app]"
       }
     end
     before do
       @resource.user deploy_user
       @resource.ssh_wrapper wrapper
+      Etc.stub!(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/deployNinja"))
     end
     context "without a timeout set" do
       it "clones a repo with default git options" do
@@ -198,11 +199,13 @@ SHAS
 
   it "runs a clone command with escaped destination" do
     @resource.user "deployNinja"
+    Etc.stub!(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/deployNinja"))
     @resource.destination "/Application Support/with/space"
     @resource.ssh_wrapper "do_it_this_way.sh"
     expected_cmd = "git clone  \"git://github.com/opscode/chef.git\" \"/Application Support/with/space\""
     @provider.should_receive(:shell_out!).with(expected_cmd, :user => "deployNinja",
-                                                :environment =>{"GIT_SSH"=>"do_it_this_way.sh"},
+                                                :environment =>{"GIT_SSH"=>"do_it_this_way.sh",
+                                                                "HOME" => "/home/deployNinja"},
                                                 :log_tag => "git[web2.0 app]")
     @provider.clone
   end
@@ -252,11 +255,14 @@ SHAS
 
   it "runs a sync command with the user and group specified in the resource" do
     @resource.user("whois")
+    Etc.stub!(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/whois"))
     @resource.group("thisis")
     @provider.should_receive(:setup_remote_tracking_branches).with(@resource.remote, @resource.repository)
     expected_cmd = "git fetch origin && git fetch origin --tags && git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
     @provider.should_receive(:shell_out!).with(expected_cmd, :cwd => "/my/deploy/dir",
-                                                :user => "whois", :group => "thisis", :log_tag => "git[web2.0 app]")
+                                                :user => "whois", :group => "thisis",
+                                                :log_tag => "git[web2.0 app]",
+                                                :environment=>{"HOME"=>"/home/whois"})
     @provider.fetch_updates
   end
 
@@ -296,6 +302,7 @@ SHAS
     it "runs the config with the user and group specified in the resource" do
       @resource.user("whois")
       @resource.group("thisis")
+      Etc.stub!(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/whois"))
       command_response = double('shell_out')
       command_response.stub(:exitstatus) { 1 }
       expected_command = "git config --get remote.#{@resource.remote}.url"
@@ -304,13 +311,15 @@ SHAS
                                                  :log_tag => "git[web2.0 app]",
                                                  :user => "whois",
                                                  :group => "thisis",
+                                                 :environment=>{"HOME"=>"/home/whois"},
                                                  :returns => [0,1,2]).and_return(command_response)
       add_remote_command = "git remote add #{@resource.remote} #{@resource.repository}"
       @provider.should_receive(:shell_out!).with(add_remote_command,
                                                  :cwd => "/my/deploy/dir",
                                                  :log_tag => "git[web2.0 app]",
                                                  :user => "whois",
-                                                 :group => "thisis")
+                                                 :group => "thisis",
+                                                 :environment=>{"HOME"=>"/home/whois"})
       @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
     end
 
@@ -402,6 +411,21 @@ SHAS
     # @resource.should be_updated
   end
 
+  it "does not call checkout if enable_checkout is false" do
+    # will be invoked in load_current_resource
+    ::File.stub!(:exist?).with("/my/deploy/dir/.git").and_return(false)
+
+    ::File.stub!(:exist?).with("/my/deploy/dir").and_return(true)
+    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::Dir.stub!(:entries).with("/my/deploy/dir").and_return(['.','..'])
+
+    @resource.enable_checkout false
+    @provider.should_receive(:clone)
+    @provider.should_not_receive(:checkout)
+    @provider.should_receive(:enable_submodules)
+    @provider.run_action(:checkout)
+  end
+
   # REGRESSION TEST: on some OSes, the entries from an empty directory will be listed as
   # ['..', '.'] but this shouldn't change the behavior
   it "does a checkout by cloning the repo and then enabling submodules when the directory entries are listed as %w{.. .}" do

data/spec/unit/provider/group/dscl_spec.rb

@@ -265,6 +265,7 @@ describe Chef::Provider::Group::Dscl do
     it "should manage the group_name if it changed and the new resources group_name is not null" do
       @current_resource.group_name("oldval")
       @new_resource.group_name("newname")
+      @provider.should_receive(:set_members).and_return(true)
       @provider.should_receive(:safe_dscl).with("create /Groups/newname")
       @provider.should_receive(:safe_dscl).with("create /Groups/newname Password '*'")
       @provider.manage_group