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

data/spec/unit/shell_out_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Chef::ShellOut deprecation notices" do
+  it "logs a warning when initializing a new Chef::ShellOut object" do
+    Chef::Log.should_receive(:warn).with("Chef::ShellOut is deprecated, please use Mixlib::ShellOut")
+    Chef::Log.should_receive(:warn).with(/Called from\:/)
+    Chef::ShellOut.new("pwd")
+  end
+end
+
+describe "Chef::Exceptions::ShellCommandFailed deprecation notices" do
+
+  it "logs a warning when referencing the constant Chef::Exceptions::ShellCommandFailed" do
+    Chef::Log.should_receive(:warn).with("Chef::Exceptions::ShellCommandFailed is deprecated, use Mixlib::ShellOut::ShellCommandFailed")
+    Chef::Log.should_receive(:warn).with(/Called from\:/)
+    Chef::Exceptions::ShellCommandFailed
+  end
+end

data/spec/unit/{shef_spec.rb → shell_spec.rb}

@@ -19,7 +19,7 @@ require 'spec_helper'
 require "ostruct"
 
 ObjectTestHarness = Proc.new do
-  extend Shef::Extensions::ObjectCoreExtensions
+  extend Shell::Extensions::ObjectCoreExtensions
 
   def conf=(new_conf)
     @conf = new_conf
@@ -38,36 +38,36 @@ class TestJobManager
   attr_accessor :jobs
 end
 
-describe Shef do
+describe Shell do
 
   before do
-    Shef.irb_conf = {}
-    Shef::ShefSession.instance.rspec_reset
-    Shef::ShefSession.instance.stub!(:reset!)
+    Shell.irb_conf = {}
+    Shell::ShellSession.instance.rspec_reset
+    Shell::ShellSession.instance.stub!(:reset!)
   end
 
   describe "reporting its status" do
 
     it "alway says it is running" do
-      Shef.should be_running
+      Shell.should be_running
     end
 
   end
 
   describe "configuring IRB" do
     it "configures irb history" do
-      Shef.configure_irb
-      Shef.irb_conf[:HISTORY_FILE].should == "~/.shef_history"
-      Shef.irb_conf[:SAVE_HISTORY].should == 1000
+      Shell.configure_irb
+      Shell.irb_conf[:HISTORY_FILE].should == "~/.chef/chef_shell_history"
+      Shell.irb_conf[:SAVE_HISTORY].should == 1000
     end
 
     it "has a prompt like ``chef > '' in the default context" do
-      Shef.configure_irb
+      Shell.configure_irb
 
       conf = OpenStruct.new
       conf.main = Object.new
       conf.main.instance_eval(&ObjectTestHarness)
-      Shef.irb_conf[:IRB_RC].call(conf)
+      Shell.irb_conf[:IRB_RC].call(conf)
       conf.prompt_c.should      == "chef > "
       conf.return_format.should == " => %s \n"
       conf.prompt_i.should      == "chef > "
@@ -77,12 +77,12 @@ describe Shef do
     end
 
     it "has a prompt like ``chef:recipe > '' in recipe context" do
-      Shef.configure_irb
+      Shell.configure_irb
 
       conf = OpenStruct.new
       events = Chef::EventDispatch::Dispatcher.new
       conf.main = Chef::Recipe.new(nil,nil,Chef::RunContext.new(Chef::Node.new, {}, events))
-      Shef.irb_conf[:IRB_RC].call(conf)
+      Shell.irb_conf[:IRB_RC].call(conf)
       conf.prompt_c.should      == "chef:recipe > "
       conf.prompt_i.should      == "chef:recipe > "
       conf.prompt_n.should      == "chef:recipe ?> "
@@ -90,11 +90,11 @@ describe Shef do
     end
 
     it "has a prompt like ``chef:attributes > '' in attributes/node context" do
-      Shef.configure_irb
+      Shell.configure_irb
 
       conf = OpenStruct.new
       conf.main = Chef::Node.new
-      Shef.irb_conf[:IRB_RC].call(conf)
+      Shell.irb_conf[:IRB_RC].call(conf)
       conf.prompt_c.should      == "chef:attributes > "
       conf.prompt_i.should      == "chef:attributes > "
       conf.prompt_n.should      == "chef:attributes ?> "
@@ -111,7 +111,7 @@ describe Shef do
     end
 
     it "creates help text for methods with descriptions" do
-      @chef_object.help_descriptions.should == [Shef::Extensions::Help.new("rspec_method", "rspecin'", nil)]
+      @chef_object.help_descriptions.should == [Shell::Extensions::Help.new("rspec_method", "rspecin'", nil)]
     end
 
     it "adds help text when a new method is described then defined" do
@@ -121,8 +121,8 @@ describe Shef do
         end
       EVAL
       @chef_object.instance_eval describe_define
-      @chef_object.help_descriptions.should == [Shef::Extensions::Help.new("rspec_method", "rspecin'"),
-                                                Shef::Extensions::Help.new("baz", "foo2the Bar")]
+      @chef_object.help_descriptions.should == [Shell::Extensions::Help.new("rspec_method", "rspecin'"),
+                                                Shell::Extensions::Help.new("baz", "foo2the Bar")]
     end
 
     it "adds help text for subcommands" do
@@ -132,8 +132,8 @@ describe Shef do
         end
       EVAL
       @chef_object.instance_eval describe_define
-      expected_help_text_fragments = [Shef::Extensions::Help.new("rspec_method", "rspecin'")]
-      expected_help_text_fragments << Shef::Extensions::Help.new("baz.baz_obj_command", "something you can do with baz.baz_obj_command")
+      expected_help_text_fragments = [Shell::Extensions::Help.new("rspec_method", "rspecin'")]
+      expected_help_text_fragments << Shell::Extensions::Help.new("baz.baz_obj_command", "something you can do with baz.baz_obj_command")
       @chef_object.help_descriptions.should == expected_help_text_fragments
     end
 

data/spec/unit/user_spec.rb

@@ -0,0 +1,255 @@
+#
+# Author:: Steven Danna (steve@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'
+
+require 'chef/user'
+require 'tempfile'
+
+describe Chef::User do
+  before(:each) do
+    @user = Chef::User.new
+  end
+
+  describe "initialize" do
+    it "should be a Chef::User" do
+      @user.should be_a_kind_of(Chef::User)
+    end
+  end
+
+  describe "name" do
+    it "should let you set the name to a string" do
+      @user.name("ops_master").should == "ops_master"
+    end
+
+    it "should return the current name" do
+      @user.name "ops_master"
+      @user.name.should == "ops_master"
+    end
+
+    # It is not feasible to check all invalid characters.  Here are a few
+    # that we probably care about.
+    it "should not accept invalid characters" do
+      # capital letters
+      lambda { @user.name "Bar" }.should raise_error(ArgumentError)
+      # slashes
+      lambda { @user.name "foo/bar" }.should raise_error(ArgumentError)
+      # ?
+      lambda { @user.name "foo?" }.should raise_error(ArgumentError)
+      # &
+      lambda { @user.name "foo&" }.should raise_error(ArgumentError)
+    end
+
+
+    it "should not accept spaces" do
+      lambda { @user.name "ops master" }.should raise_error(ArgumentError)
+    end
+
+    it "should throw an ArgumentError if you feed it anything but a string" do
+      lambda { @user.name Hash.new }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "admin" do
+    it "should let you set the admin bit" do
+      @user.admin(true).should == true
+    end
+
+    it "should return the current admin value" do
+      @user.admin true
+      @user.admin.should == true
+    end
+
+    it "should default to false" do
+      @user.admin.should == false
+    end
+
+    it "should throw an ArgumentError if you feed it anything but true or false" do
+      lambda { @user.name Hash.new }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "public_key" do
+    it "should let you set the public key" do
+      @user.public_key("super public").should == "super public"
+    end
+
+    it "should return the current public key" do
+      @user.public_key("super public")
+      @user.public_key.should == "super public"
+    end
+
+    it "should throw an ArgumentError if you feed it something lame" do
+      lambda { @user.public_key Hash.new }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "private_key" do
+    it "should let you set the private key" do
+      @user.private_key("super private").should == "super private"
+    end
+
+    it "should return the private key" do
+      @user.private_key("super private")
+      @user.private_key.should == "super private"
+    end
+
+    it "should throw an ArgumentError if you feed it something lame" do
+      lambda { @user.private_key Hash.new }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "when serializing to JSON" do
+    before(:each) do
+      @user.name("black")
+      @user.public_key("crowes")
+      @json = @user.to_json
+    end
+
+    it "serializes as a JSON object" do
+      @json.should match(/^\{.+\}$/)
+    end
+
+    it "includes the name value" do
+      @json.should include(%q{"name":"black"})
+    end
+
+    it "includes the public key value" do
+      @json.should include(%{"public_key":"crowes"})
+    end
+
+    it "includes the 'admin' flag" do
+      @json.should include(%q{"admin":false})
+    end
+
+    it "includes the private key when present" do
+      @user.private_key("monkeypants")
+      @user.to_json.should include(%q{"private_key":"monkeypants"})
+    end
+
+    it "does not include the private key if not present" do
+      @json.should_not include("private_key")
+    end
+
+    it "includes the password if present" do
+      @user.password "password"
+      @user.to_json.should include(%q{"password":"password"})
+    end
+
+    it "does not include the password if not present" do
+      @json.should_not include("password")
+    end
+  end
+
+  describe "when deserializing from JSON" do
+    before(:each) do
+      user = { "name" => "mr_spinks",
+        "public_key" => "turtles",
+        "private_key" => "pandas",
+        "password" => "password",
+        "admin" => true }
+      @user = Chef::User.from_json(user.to_json)
+    end
+
+    it "should deserialize to a Chef::User object" do
+      @user.should be_a_kind_of(Chef::User)
+    end
+
+    it "preserves the name" do
+      @user.name.should == "mr_spinks"
+    end
+
+    it "preserves the public key" do
+      @user.public_key.should == "turtles"
+    end
+
+    it "preserves the admin status" do
+      @user.admin.should be_true
+    end
+
+    it "includes the private key if present" do
+      @user.private_key.should == "pandas"
+    end
+
+    it "includes the password if present" do
+      @user.password.should == "password"
+    end
+
+  end
+
+  describe "API Interactions" do
+    before (:each) do
+      @user = Chef::User.new
+      @user.name "foobar"
+      @http_client = mock("Chef::REST mock")
+      Chef::REST.stub!(:new).and_return(@http_client)
+    end
+
+    describe "list" do
+      before(:each) do
+        Chef::Config[:chef_server_url] = "http://www.example.com"
+        @osc_response = { "admin" => "http://www.example.com/users/admin"}
+        @ohc_response = [ { "user" => { "username" => "admin" }} ]
+      end
+
+      it "lists all clients on an OSC server" do
+        @http_client.stub!(:get_rest).with("users").and_return(@osc_response)
+        Chef::User.list.should == @osc_response
+      end
+
+      it "lists all clients on an OHC/OPC server" do
+        @http_client.stub!(:get_rest).with("users").and_return(@ohc_response)
+        # We expect that Chef::User.list will give a consistent response
+        # so OHC API responses should be transformed to OSC-style output.
+        Chef::User.list.should == @osc_response
+      end
+    end
+
+    describe "create" do
+      it "creates a new user via the API" do
+        @user.password "password"
+        @http_client.should_receive(:post_rest).with("users", {:name => "foobar", :admin => false, :password => "password"}).and_return({})
+        @user.create
+      end
+    end
+
+    describe "read" do
+      it "loads a named user from the API" do
+        @http_client.should_receive(:get_rest).with("users/foobar").and_return({"name" => "foobar", "admin" => true, "public_key" => "pubkey"})
+        user = Chef::User.load("foobar")
+        user.name.should == "foobar"
+        user.admin.should == true
+        user.public_key.should == "pubkey"
+      end
+    end
+
+    describe "update" do
+      it "updates an existing user on via the API" do
+        @http_client.should_receive(:put_rest).with("users/foobar", {:name => "foobar", :admin => false}).and_return({})
+        @user.update
+      end
+    end
+
+    describe "destroy" do
+      it "deletes the specified user via the API" do
+        @http_client.should_receive(:delete_rest).with("users/foobar")
+        @user.destroy
+      end
+    end
+  end
+end

data/spec/unit/util/backup_spec.rb

@@ -0,0 +1,149 @@
+#
+# Author:: Lamont Granquist (<lamont@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'
+require 'tmpdir'
+
+describe Chef::Util::Backup do
+  before(:all) do
+    @original_config = Chef::Config.configuration
+  end
+
+  after(:all) do
+    Chef::Config.configuration.replace(@original_config)
+  end
+
+  let (:tempfile) do
+    Tempfile.new("chef-util-backup-spec-test")
+  end
+
+  before(:each) do
+    @new_resource = mock("new_resource")
+    @new_resource.should_receive(:path).at_least(:once).and_return(tempfile.path)
+    @backup = Chef::Util::Backup.new(@new_resource)
+  end
+
+  it "should store the resource passed to new as new_resource" do
+    @backup.new_resource.should eql(@new_resource)
+  end
+
+  describe "for cases when we don't want to back anything up" do
+
+    before(:each) do
+      @backup.should_not_receive(:do_backup)
+    end
+
+    it "should not attempt to backup a file if :backup is false" do
+      @new_resource.should_receive(:backup).at_least(:once).and_return(false)
+      @backup.backup!
+    end
+
+    it "should not attempt to backup a file if :backup == 0" do
+      @new_resource.should_receive(:backup).at_least(:once).and_return(0)
+      @backup.backup!
+    end
+
+    it "should not attempt to backup a file if it does not exist" do
+      @new_resource.should_receive(:backup).at_least(:once).and_return(1)
+      File.should_receive(:exist?).with(tempfile.path).at_least(:once).and_return(false)
+      @backup.backup!
+    end
+
+  end
+
+  describe "for cases when we want to back things up" do
+    before(:each) do
+      @backup.should_receive(:do_backup)
+    end
+
+    describe "when the number of backups is specified as 1" do
+      before(:each) do
+        @new_resource.should_receive(:backup).at_least(:once).and_return(1)
+      end
+
+      it "should not delete anything if this is the only backup" do
+        @backup.should_receive(:sorted_backup_files).and_return(['a'])
+        @backup.should_not_receive(:delete_backup)
+        @backup.backup!
+      end
+
+      it "should keep only 1 backup copy" do
+        @backup.should_receive(:sorted_backup_files).and_return(['a', 'b', 'c'])
+        @backup.should_receive(:delete_backup).with('b')
+        @backup.should_receive(:delete_backup).with('c')
+        @backup.backup!
+      end
+    end
+
+    describe "when the number of backups is specified as 2" do
+      before(:each) do
+        @new_resource.should_receive(:backup).at_least(:once).and_return(2)
+      end
+
+      it "should not delete anything if we only have one other backup" do
+        @backup.should_receive(:sorted_backup_files).and_return(['a', 'b'])
+        @backup.should_not_receive(:delete_backup)
+        @backup.backup!
+      end
+
+      it "should keep only 2 backup copies" do
+        @backup.should_receive(:sorted_backup_files).and_return(['a', 'b', 'c', 'd'])
+        @backup.should_receive(:delete_backup).with('c')
+        @backup.should_receive(:delete_backup).with('d')
+        @backup.backup!
+      end
+    end
+  end
+
+  describe "backup_filename" do
+    it "should return a timestamped path" do
+      @backup.should_receive(:path).and_return('/a/b/c.txt')
+      @backup.send(:backup_filename).should =~ %r|^/a/b/c.txt.chef-\d{14}$|
+    end
+    it "should strip the drive letter off for windows" do
+      @backup.should_receive(:path).and_return('c:\a\b\c.txt')
+      @backup.send(:backup_filename).should =~ %r|^\\a\\b\\c.txt.chef-\d{14}$|
+    end
+    it "should strip the drive letter off for windows (with forwardslashes)" do
+      @backup.should_receive(:path).and_return('c:/a/b/c.txt')
+      @backup.send(:backup_filename).should =~ %r|^/a/b/c.txt.chef-\d{14}$|
+    end
+  end
+
+  describe "backup_path" do
+    it "uses the file's directory when Chef::Config[:file_backup_path] is nil" do
+      @backup.should_receive(:path).and_return('/a/b/c.txt')
+      Chef::Config[:file_backup_path] = nil
+      @backup.send(:backup_path).should =~ %r|^/a/b/c.txt.chef-\d{14}$|
+    end
+
+    it "uses the configured Chef::Config[:file_backup_path]" do
+      @backup.should_receive(:path).and_return('/a/b/c.txt')
+      Chef::Config[:file_backup_path] = '/backupdir'
+      @backup.send(:backup_path).should =~ %r|^/backupdir[\\/]+a/b/c.txt.chef-\d{14}$|
+    end
+
+    it "uses the configured Chef::Config[:file_backup_path] and strips the drive on windows" do
+      @backup.should_receive(:path).and_return('c:\\a\\b\\c.txt')
+      Chef::Config[:file_backup_path] = 'c:\backupdir'
+      @backup.send(:backup_path).should =~ %r|^c:\\backupdir[\\/]+a\\b\\c.txt.chef-\d{14}$|
+    end
+  end
+
+end