chef 10.28.2-x86-mingw32

data/spec/unit/openid_registration_spec.rb

@@ -0,0 +1,153 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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::OpenIDRegistration, "initialize" do
+  it "should return a new Chef::OpenIDRegistration object" do
+    Chef::OpenIDRegistration.new.should be_kind_of(Chef::OpenIDRegistration)
+  end
+end
+
+describe Chef::OpenIDRegistration, "set_password" do
+  it "should generate a salt for this object" do
+    oreg = Chef::OpenIDRegistration.new
+    oreg.salt.should eql(nil)
+    oreg.set_password("foolio")
+    oreg.salt.should_not eql(nil)
+  end
+  
+  it "should encrypt the password with the salt and the plaintext password" do
+    oreg = Chef::OpenIDRegistration.new
+    oreg.set_password("foolio")
+    oreg.password.should_not eql(nil)
+  end
+end
+
+describe Chef::OpenIDRegistration, "to_json" do
+  it "should serialize itself as json" do
+    oreg = Chef::OpenIDRegistration.new
+    oreg.set_password("monkey")
+    json = oreg.to_json
+    %w{json_class chef_type name salt password validated}.each do |verify|
+      json.should =~ /#{verify}/
+    end
+  end
+end
+
+describe Chef::OpenIDRegistration, "from_json" do
+  it "should serialize itself as json" do
+    oreg = Chef::OpenIDRegistration.new()
+    oreg.name = "foobar"
+    oreg.set_password("monkey")
+    oreg_json = oreg.to_json
+    nreg = Chef::JSONCompat.from_json(oreg_json)
+    nreg.should be_a_kind_of(Chef::OpenIDRegistration)
+    %w{name salt password validated}.each do |verify|
+      nreg.send(verify.to_sym).should eql(oreg.send(verify.to_sym))
+    end
+  end
+end
+
+describe Chef::OpenIDRegistration, "list" do  
+  before(:each) do
+    @mock_couch = mock("Chef::CouchDB")
+    @mock_couch.stub!(:list).and_return({
+      "rows" => [
+        {
+          "value" => "a",
+          "key"   => "avenue"
+        }
+      ]
+    })
+    Chef::CouchDB.stub!(:new).and_return(@mock_couch)
+  end
+  
+  it "should retrieve a list of nodes from CouchDB" do
+    Chef::OpenIDRegistration.list.should eql(["avenue"])
+  end
+  
+  it "should return just the ids if inflate is false" do
+    Chef::OpenIDRegistration.list(false).should eql(["avenue"])
+  end
+  
+  it "should return the full objects if inflate is true" do
+    Chef::OpenIDRegistration.list(true).should eql(["a"])
+  end
+end
+
+describe Chef::OpenIDRegistration, "load" do
+  it "should load a registration from couchdb by name" do
+    @mock_couch = mock("Chef::CouchDB")
+    Chef::CouchDB.stub!(:new).and_return(@mock_couch)
+    @mock_couch.should_receive(:load).with("openid_registration", "coffee").and_return(true)
+    Chef::OpenIDRegistration.load("coffee")
+  end
+end
+
+describe Chef::OpenIDRegistration, "destroy" do
+  it "should delete this registration from couchdb" do
+    @mock_couch = mock("Chef::CouchDB")
+    @mock_couch.should_receive(:delete).with("openid_registration", "bob", 1).and_return(true)
+    Chef::CouchDB.stub!(:new).and_return(@mock_couch)
+    reg = Chef::OpenIDRegistration.new
+    reg.name = "bob"
+    reg.couchdb_rev = 1
+    reg.destroy
+  end
+end
+
+describe Chef::OpenIDRegistration, "save" do
+  before(:each) do
+    @mock_couch = mock("Chef::CouchDB")
+    Chef::CouchDB.stub!(:new).and_return(@mock_couch)
+    @reg = Chef::OpenIDRegistration.new
+    @reg.name = "bob"
+    @reg.couchdb_rev = 1
+  end
+  
+  it "should save the registration to couchdb" do
+    @mock_couch.should_receive(:store).with("openid_registration", "bob", @reg).and_return({ "rev" => 33 }) 
+    @reg.save
+  end
+  
+  it "should store the new couchdb_rev" do
+    @mock_couch.stub!(:store).with("openid_registration", "bob", @reg).and_return({ "rev" => 33 }) 
+    @reg.save
+    @reg.couchdb_rev.should eql(33)
+  end
+end
+
+describe Chef::OpenIDRegistration, "create_design_document" do
+  it "should create our design document" do
+    mock_couch = mock("Chef::CouchDB")
+    mock_couch.should_receive(:create_design_document).with("registrations", Chef::OpenIDRegistration::DESIGN_DOCUMENT)
+    Chef::CouchDB.stub!(:new).and_return(mock_couch)
+    Chef::OpenIDRegistration.create_design_document
+  end
+end
+
+describe Chef::OpenIDRegistration, "has_key?" do
+  it "should check with CouchDB for a registration with this key" do
+    @mock_couch = mock("Chef::CouchDB")
+    @mock_couch.should_receive(:has_key?).with("openid_registration", "bob").and_return(true)
+    Chef::CouchDB.stub!(:new).and_return(@mock_couch)
+    Chef::OpenIDRegistration.has_key?("bob")
+  end
+end
+

data/spec/unit/platform_spec.rb

@@ -0,0 +1,241 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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::Platform supports" do
+  [
+    :mac_os_x,
+    :mac_os_x_server,
+    :freebsd,
+    :ubuntu,
+    :debian,
+    :centos,
+    :fedora,
+    :suse,
+    :redhat,
+    :oracle,
+    :gentoo,
+    :arch, 
+    :solaris,
+    :mswin,
+    :mingw32,
+    :windows,
+    :gcel
+  ].each do |platform|
+    it "#{platform}" do
+      Chef::Platform.platforms.should have_key(platform)
+    end
+  end
+end
+
+describe Chef::Platform do
+
+  before :all do
+    @original_platform_map = Chef::Platform.platforms
+  end
+  
+  after :all do ||
+    Chef::Platform.platforms = @original_platform_map
+  end
+  
+  before(:each) do
+    Chef::Platform.platforms = {
+      :darwin => {
+        "9.2.2" => {
+          :file => "darwinian",
+          :else => "thing"
+        },
+        :default => {
+          :file => "old school",
+          :snicker => "snack"
+        }
+      },
+      :mars_volta => {
+      },
+      :default => {
+        :file => Chef::Provider::File,
+        :pax => "brittania",
+        :cat => "nice"
+      }
+    }
+    @events = Chef::EventDispatch::Dispatcher.new
+  end
+  
+  it "should allow you to look up a platform by name and version, returning the provider map for it" do
+    pmap = Chef::Platform.find("Darwin", "9.2.2")
+    pmap.should be_a_kind_of(Hash)
+    pmap[:file].should eql("darwinian")
+  end
+  
+  it "should use the default providers for an os if the specific version does not exist" do
+    pmap = Chef::Platform.find("Darwin", "1")
+    pmap.should be_a_kind_of(Hash)
+    pmap[:file].should eql("old school")
+  end
+  
+  it "should use the default providers if the os doesn't give me a default, but does exist" do
+    pmap = Chef::Platform.find("mars_volta", "1")
+    pmap.should be_a_kind_of(Hash)
+    pmap[:file].should eql(Chef::Provider::File)
+  end
+  
+  it "should use the default provider if the os does not exist" do
+    pmap = Chef::Platform.find("AIX", "1")
+    pmap.should be_a_kind_of(Hash)
+    pmap[:file].should eql(Chef::Provider::File)
+  end
+  
+  it "should merge the defaults for an os with the specific version" do
+    pmap = Chef::Platform.find("Darwin", "9.2.2")
+    pmap[:file].should eql("darwinian")
+    pmap[:snicker].should eql("snack")
+  end
+  
+  it "should merge the defaults for an os with the universal defaults" do
+    pmap = Chef::Platform.find("Darwin", "9.2.2")
+    pmap[:file].should eql("darwinian")
+    pmap[:pax].should eql("brittania")
+  end
+  
+  it "should allow you to look up a provider for a platform directly by symbol" do
+    Chef::Platform.find_provider("Darwin", "9.2.2", :file).should eql("darwinian")
+  end
+  
+  it "should raise an exception if a provider cannot be found for a resource type" do
+    lambda { Chef::Platform.find_provider("Darwin", "9.2.2", :coffee) }.should raise_error(ArgumentError)
+  end
+  
+  it "should look up a provider for a resource with a Chef::Resource object" do
+    kitty = Chef::Resource::Cat.new("loulou")
+    Chef::Platform.find_provider("Darwin", "9.2.2", kitty).should eql("nice")
+  end
+  
+  it "should look up a provider with a node and a Chef::Resource object" do
+    kitty = Chef::Resource::Cat.new("loulou")    
+    node = Chef::Node.new
+    node.name("Intel")
+    node.platform("mac_os_x")
+    node.platform_version("9.2.2")
+    Chef::Platform.find_provider_for_node(node, kitty).should eql("nice")
+  end
+
+  it "should prefer an explicit provider" do
+    kitty = Chef::Resource::Cat.new("loulou")    
+    kitty.stub!(:provider).and_return(Chef::Provider::File)
+    node = Chef::Node.new
+    node.name("Intel")
+    node.platform("mac_os_x")
+    node.platform_version("9.2.2")
+    Chef::Platform.find_provider_for_node(node, kitty).should eql(Chef::Provider::File)
+  end
+
+  it "should look up a provider based on the resource name if nothing else matches" do
+    kitty = Chef::Resource::Cat.new("loulou")
+    class Chef::Provider::Cat < Chef::Provider; end
+    Chef::Platform.platforms[:default].delete(:cat)
+    node = Chef::Node.new
+    node.name("Intel")
+    node.platform("mac_os")
+    node.platform_version("8.5")
+    Chef::Platform.find_provider_for_node(node, kitty).should eql(Chef::Provider::Cat)
+  end
+ 
+  def setup_file_resource
+    node = Chef::Node.new
+    node.platform("mac_os_x")
+    node.platform_version("9.2.2")
+    run_context = Chef::RunContext.new(node, {}, @events)
+    [ Chef::Resource::File.new("whateva", run_context), run_context ]
+  end
+
+  it "returns a provider object given a Chef::Resource object which has a valid run context and an action" do
+    file, run_context = setup_file_resource
+    provider = Chef::Platform.provider_for_resource(file, :foo)
+    provider.should be_an_instance_of(Chef::Provider::File)
+    provider.new_resource.should equal(file)
+    provider.run_context.should equal(run_context)
+  end
+  
+  it "returns a provider object given a Chef::Resource object which has a valid run context without an action" do
+    file, run_context = setup_file_resource
+    provider = Chef::Platform.provider_for_resource(file)
+    provider.should be_an_instance_of(Chef::Provider::File)
+    provider.new_resource.should equal(file)
+    provider.run_context.should equal(run_context)
+  end
+  
+  it "raises an error when trying to find the provider for a resource with no run context" do
+    file = Chef::Resource::File.new("whateva")
+    lambda {Chef::Platform.provider_for_resource(file)}.should raise_error(ArgumentError)
+  end
+
+  it "does not support finding a provider by resource and node -- a run context is required" do
+    lambda {Chef::Platform.provider_for_node('node', 'resource')}.should raise_error(NotImplementedError)
+  end
+
+  it "should update the provider map with map" do  
+    Chef::Platform.set(
+         :platform => :darwin,
+         :version => "9.2.2",
+         :resource => :file, 
+         :provider => "masterful"
+    )
+    Chef::Platform.platforms[:darwin]["9.2.2"][:file].should eql("masterful")
+    Chef::Platform.set(
+         :platform => :darwin,
+         :resource => :file,
+         :provider => "masterful" 
+    )
+    Chef::Platform.platforms[:darwin][:default][:file].should eql("masterful")
+    Chef::Platform.set(
+         :resource => :file, 
+         :provider => "masterful"
+    )   
+    Chef::Platform.platforms[:default][:file].should eql("masterful")
+    
+    Chef::Platform.set(
+         :platform => :hero,
+         :version => "9.2.2",
+         :resource => :file, 
+         :provider => "masterful"
+    )
+    Chef::Platform.platforms[:hero]["9.2.2"][:file].should eql("masterful")
+    
+    Chef::Platform.set(
+         :resource => :file, 
+         :provider => "masterful"
+    )
+    Chef::Platform.platforms[:default][:file].should eql("masterful")
+    
+    Chef::Platform.platforms = {}
+    
+    Chef::Platform.set(
+         :resource => :file, 
+         :provider => "masterful"
+    )
+    Chef::Platform.platforms[:default][:file].should eql("masterful")
+
+    Chef::Platform.platforms = { :neurosis => {} }
+    Chef::Platform.set(:platform => :neurosis, :resource => :package, :provider => "masterful")
+    Chef::Platform.platforms[:neurosis][:default][:package].should eql("masterful")
+    
+  end
+  
+  
+end

data/spec/unit/provider/breakpoint_spec.rb

@@ -0,0 +1,54 @@
+#
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2008 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::Provider::Breakpoint do
+  
+  before do
+    @resource = Chef::Resource::Breakpoint.new
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @collection = mock("resource collection")
+    @run_context.stub!(:resource_collection).and_return(@collection)
+    @provider = Chef::Provider::Breakpoint.new(@resource, @run_context)
+  end
+  
+  it "responds to load_current_resource" do
+    @provider.should respond_to(:load_current_resource)
+  end
+  
+  it "gets the iterator from @collection and pauses it" do
+    Shef.stub!(:running?).and_return(true)
+    @iterator = mock("stepable_iterator")
+    @collection.stub!(:iterator).and_return(@iterator)
+    @iterator.should_receive(:pause)
+    @provider.action_break
+    @resource.should be_updated
+  end
+
+  it "doesn't pause the iterator if Shef isn't running" do
+    Shef.stub!(:running?).and_return(false)
+    @iterator = mock("stepable_iterator")
+    @collection.stub!(:iterator).and_return(@iterator)
+    @iterator.should_not_receive(:pause)
+    @provider.action_break
+  end
+
+end

data/spec/unit/provider/cookbook_file_spec.rb

@@ -0,0 +1,218 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010 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 'ostruct'
+
+describe Chef::Provider::CookbookFile do
+  before do
+    Chef::FileAccessControl.any_instance.stub(:set_all)
+    Chef::FileAccessControl.any_instance.stub(:modified?).and_return(true)
+    @cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
+    Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, @cookbook_repo) }
+
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @cookbook_collection = Chef::CookbookCollection.new(Chef::CookbookLoader.new(@cookbook_repo))
+    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+
+    @new_resource = Chef::Resource::CookbookFile.new('apache2_module_conf_generate.pl', @run_context)
+    @new_resource.cookbook_name = 'apache2'
+    @provider = Chef::Provider::CookbookFile.new(@new_resource, @run_context)
+
+    @file_content=<<-EXPECTED
+# apache2_module_conf_generate.pl
+# this is just here for show.
+EXPECTED
+
+  end
+
+  it "prefers the explicit cookbook name on the resource to the implicit one" do
+    @new_resource.cookbook('nginx')
+    @provider.resource_cookbook.should == 'nginx'
+  end
+
+  it "falls back to the implicit cookbook name on the resource" do
+    @provider.resource_cookbook.should == 'apache2'
+  end
+
+  describe "when loading the current file state" do
+
+    it "converts windows-y filenames to unix-y ones" do
+      @new_resource.path('windows\stuff')
+      @provider.load_current_resource
+      @new_resource.path.should == 'windows/stuff'
+    end
+
+    it "sets the current resources path to the same as the new resource" do
+      @new_resource.path('/tmp/file')
+      @provider.load_current_resource
+      @provider.current_resource.path.should == '/tmp/file'
+    end
+  end
+
+  describe "when the enclosing directory of the target file location doesn't exist" do
+    before do
+      @new_resource.path("/tmp/no/such/intermediate/path/file.txt")
+    end
+
+    it "raises a specific error alerting the user to the problem" do
+      lambda {@provider.run_action(:create)}.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+    end
+  end
+  describe "when the file doesn't yet exist" do
+    before do
+      @install_to = Dir.tmpdir + '/apache2_modconf.pl'
+
+      @current_resource = @new_resource.dup
+      @provider.current_resource = @current_resource
+    end
+
+    after { ::File.exist?(@install_to) && FileUtils.rm(@install_to) }
+
+    it "loads the current file state" do
+      @provider.load_current_resource
+      @provider.current_resource.checksum.should be_nil
+    end
+
+    it "looks up a file from the cookbook cache" do
+      expected = CHEF_SPEC_DATA + "/cookbooks/apache2/files/default/apache2_module_conf_generate.pl"
+      @provider.file_cache_location.should == expected
+    end
+
+    it "stages the cookbook to a temporary file" do
+      @new_resource.path(@install_to)
+      @provider.should_receive(:deploy_tempfile)
+      @provider.run_action(:create)
+    end
+
+    it "installs the file from the cookbook cache" do
+      @new_resource.path(@install_to)
+      @provider.should_receive(:backup_new_resource)
+      @provider.stub!(:update_new_file_state)
+      @provider.run_action(:create)
+      actual = IO.read(@install_to)
+      actual.should == @file_content
+    end
+
+    it "installs the file for create_if_missing --> from Provider::File" do
+      @new_resource.path(@install_to)
+      @provider.should_receive(:backup_new_resource)
+      @provider.stub!(:update_new_file_state)
+      @provider.run_action(:create_if_missing)
+      actual = IO.read(@install_to)
+      actual.should == @file_content
+    end
+
+    it "marks the resource as updated by the last action --> being tested in the converge framework" do
+      @new_resource.path(@install_to)
+      @provider.stub!(:backup_new_resource)
+      @provider.stub!(:set_file_access_controls)
+      @provider.stub!(:update_new_file_state)
+      @provider.run_action(:create)
+      @new_resource.should be_updated
+      @new_resource.should be_updated_by_last_action
+    end
+
+  end
+
+  describe "when the file exists but has incorrect content" do
+    before do
+      @tempfile = Tempfile.open('cookbook_file_spec')
+      @new_resource.path(@target_file = @tempfile.path)
+      @tempfile.puts "the wrong content"
+      @tempfile.close
+      @current_resource = @new_resource.dup
+      @provider.current_resource = @current_resource
+    end
+
+    it "stages the cookbook to a temporary file" do
+      # prevents file backups where we might not have write access
+      @provider.should_receive(:backup_new_resource) 
+      @new_resource.path(@install_to)
+      @provider.should_receive(:deploy_tempfile)
+      @provider.run_action(:create)
+    end
+
+    it "overwrites it when the create action is called" do
+      @provider.should_receive(:backup_new_resource)
+      @provider.run_action(:create)
+      actual = IO.read(@target_file)
+      actual.should == @file_content
+    end
+
+    it "marks the resource as updated by the last action" do
+      @provider.should_receive(:backup_new_resource)
+      @provider.run_action(:create)
+      @new_resource.should be_updated
+      @new_resource.should be_updated_by_last_action
+    end
+
+    it "doesn't overwrite when the create if missing action is called" do
+      @provider.should_not_receive(:set_file_access_controls)
+      @provider.run_action(:create_if_missing)
+      actual = IO.read(@target_file)
+      actual.should == "the wrong content\n"
+    end
+
+    it "doesn't mark the resource as updated by the action for create_if_missing" do
+      @provider.run_action(:create_if_missing)
+      @new_resource.should_not be_updated
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    after { @tempfile && @tempfile.close! }
+  end
+
+  describe "when the file has the correct content" do
+    before do
+      Chef::FileAccessControl.any_instance.stub(:modified?).and_return(false)
+      @tempfile = Tempfile.open('cookbook_file_spec')
+      # CHEF-2991: We handle CRLF very poorly and we don't know what line endings
+      # our source file is going to have, so we use binary mode to preserve CRLF if needed.
+      source_file = CHEF_SPEC_DATA + "/cookbooks/apache2/files/default/apache2_module_conf_generate.pl"
+      @tempfile.binmode unless File.open(source_file, "rb") { |f| f.read =~ /\r/ }
+      @new_resource.path(@target_file = @tempfile.path)
+      @tempfile.write(@file_content)
+      @tempfile.close
+      @current_resource = @new_resource.dup
+      @provider.current_resource = @current_resource
+    end
+
+    after { @tempfile && @tempfile.unlink}
+
+    it "checks access control but does not alter content when action is create" do
+      @provider.should_receive(:set_all_access_controls)
+      @provider.should_not_receive(:stage_file_to_tmpdir)
+      @provider.run_action(:create)
+    end
+
+    it "does not mark the resource as updated by the last action" do
+      @provider.run_action(:create)
+      @new_resource.should_not be_updated
+      @new_resource.should_not be_updated_by_last_action
+    end
+
+    it "does not alter content or access control when action is create if missing" do
+      @provider.should_not_receive(:set_all_access_controls)
+      @provider.should_not_receive(:stage_file_to_tmpdir)
+      @provider.run_action(:create_if_missing)
+    end
+
+  end
+end