chef 10.34.6 → 11.0.0.beta.0

data/spec/unit/chef_fs/file_system/data_bags_dir_spec.rb

@@ -0,0 +1,220 @@
+#
+# Author:: John Keiser (<jkeiser@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/chef_fs/file_system/chef_server_root_dir'
+
+describe Chef::ChefFS::FileSystem::DataBagsDir do
+  let(:root_dir) {
+    Chef::ChefFS::FileSystem::ChefServerRootDir.new('remote',
+    {
+      :chef_server_url => 'url',
+      :node_name => 'username',
+      :client_key => 'key'
+    }, 'everything')
+  }
+  let(:data_bags_dir) { root_dir.child('data_bags') }
+  let(:should_list_data_bags) do
+    @rest.should_receive(:get_rest).with('data').once.and_return(
+      {
+        "achild" => "http://opscode.com/achild",
+        "bchild" => "http://opscode.com/bchild"
+      })
+  end
+  before(:each) do
+    @rest = double("rest")
+    Chef::REST.stub(:new).with('url','username','key') { @rest }
+  end
+
+  it 'has / as parent' do
+    data_bags_dir.parent.should == root_dir
+  end
+  it 'is a directory' do
+    data_bags_dir.dir?.should be_true
+  end
+  it 'exists' do
+    data_bags_dir.exists?.should be_true
+  end
+  it 'has name data_bags' do
+    data_bags_dir.name.should == 'data_bags'
+  end
+  it 'has path /data_bags' do
+    data_bags_dir.path.should == '/data_bags'
+  end
+  it 'has path_for_printing remote/data_bags' do
+    data_bags_dir.path_for_printing.should == 'remote/data_bags'
+  end
+  it 'has correct children' do
+    should_list_data_bags
+    data_bags_dir.children.map { |child| child.name }.should =~ %w(achild bchild)
+  end
+  it 'can have directories as children' do
+    data_bags_dir.can_have_child?('blah', true).should be_true
+  end
+  it 'cannot have files as children' do
+    data_bags_dir.can_have_child?('blah', false).should be_false
+  end
+
+  shared_examples_for 'a data bag item' do
+    it 'has data bag as parent' do
+      data_bag_item.parent.should == data_bag_dir
+    end
+    it 'is not a directory' do
+      data_bag_item.dir?.should be_false
+    end
+    it 'exists' do
+      should_list_data_bag_items
+      data_bag_item.exists?.should be_true
+    end
+    it 'has correct name' do
+      data_bag_item.name.should == data_bag_item_name
+    end
+    it 'has correct path' do
+      data_bag_item.path.should == "/data_bags/#{data_bag_dir_name}/#{data_bag_item_name}"
+    end
+    it 'has correct path_for_printing' do
+      data_bag_item.path_for_printing.should == "remote/data_bags/#{data_bag_dir_name}/#{data_bag_item_name}"
+    end
+    it 'reads correctly' do
+      @rest.should_receive(:get_rest).with("data/#{data_bag_dir_name}/#{data_bag_item_short_name}").once.and_return({
+        'a' => 'b'
+      })
+      data_bag_item.read.should == '{
+  "a": "b"
+}'
+    end
+  end
+
+  shared_examples_for 'a data bag' do
+    let(:should_list_data_bag_items) do
+      @rest.should_receive(:get_rest).with("data/#{data_bag_dir_name}").once.and_return(
+      {
+        "aitem" => "http://opscode.com/achild",
+        "bitem" => "http://opscode.com/bchild"
+      })
+    end
+    it 'has /data as a parent' do
+      data_bag_dir.parent.should == data_bags_dir
+    end
+    it 'is a directory' do
+      should_list_data_bags
+      data_bag_dir.dir?.should be_true
+    end
+    it 'exists' do
+      should_list_data_bags
+      data_bag_dir.exists?.should be_true
+    end
+    it 'has correct name' do
+      data_bag_dir.name.should == data_bag_dir_name
+    end
+    it 'has correct path' do
+      data_bag_dir.path.should == "/data_bags/#{data_bag_dir_name}"
+    end
+    it 'has correct path_for_printing' do
+      data_bag_dir.path_for_printing.should == "remote/data_bags/#{data_bag_dir_name}"
+    end
+    it 'has correct children' do
+      should_list_data_bag_items
+      data_bag_dir.children.map { |child| child.name }.should =~ %w(aitem.json bitem.json)
+    end
+    it 'can have json files as children' do
+      data_bag_dir.can_have_child?('blah.json', false).should be_true
+    end
+    it 'cannot have non-json files as children' do
+      data_bag_dir.can_have_child?('blah', false).should be_false
+    end
+    it 'cannot have directories as children' do
+      data_bag_dir.can_have_child?('blah', true).should be_false
+      data_bag_dir.can_have_child?('blah.json', true).should be_false
+    end
+    context 'aitem from data_bag.children' do
+      let(:data_bag_item) do
+        should_list_data_bag_items
+        data_bag_dir.children.select { |child| child.name == 'aitem.json' }.first
+      end
+      let(:data_bag_item_short_name) { 'aitem' }
+      let(:data_bag_item_name) { 'aitem.json' }
+      it_behaves_like 'a data bag item'
+    end
+    context 'data_bag.child(aitem)' do
+      let(:data_bag_item) { data_bag_dir.child('aitem.json') }
+      let(:data_bag_item_short_name) { 'aitem' }
+      let(:data_bag_item_name) { 'aitem.json' }
+      it_behaves_like 'a data bag item'
+    end
+    context 'nonexistent child()' do
+      let(:nonexistent_child) { data_bag_dir.child('blah.json') }
+      it 'has correct parent, name, path and path_for_printing' do
+        nonexistent_child.parent.should == data_bag_dir
+        nonexistent_child.name.should == "blah.json"
+        nonexistent_child.path.should == "/data_bags/#{data_bag_dir_name}/blah.json"
+        nonexistent_child.path_for_printing.should == "remote/data_bags/#{data_bag_dir_name}/blah.json"
+      end
+      it 'does not exist' do
+        should_list_data_bag_items
+        nonexistent_child.exists?.should be_false
+      end
+      it 'is not a directory' do
+        nonexistent_child.dir?.should be_false
+      end
+      it 'read returns NotFoundError' do
+        @rest.should_receive(:get_rest).with("data/#{data_bag_dir_name}/blah").once.and_raise(Net::HTTPServerException.new(nil,Net::HTTPResponse.new(nil,'404',nil)))
+        expect { nonexistent_child.read }.to raise_error(Chef::ChefFS::FileSystem::NotFoundError)
+      end
+    end
+  end
+
+  context 'achild from data_bags.children' do
+    let(:data_bag_dir) do
+      should_list_data_bags
+      data_bags_dir.children.select { |child| child.name == 'achild' }.first
+    end
+    let(:data_bag_dir_name) { 'achild' }
+    it_behaves_like 'a data bag'
+  end
+
+  context 'data_bags.child(achild)' do
+    let(:data_bag_dir) do
+      data_bags_dir.child('achild')
+    end
+    let(:data_bag_dir_name) { 'achild' }
+    it_behaves_like 'a data bag'
+  end
+
+  context 'nonexistent child()' do
+    let(:nonexistent_child) { data_bags_dir.child('blah') }
+    it 'has correct parent, name, path and path_for_printing' do
+      nonexistent_child.parent.should == data_bags_dir
+      nonexistent_child.name.should == "blah"
+      nonexistent_child.path.should == "/data_bags/blah"
+      nonexistent_child.path_for_printing.should == "remote/data_bags/blah"
+    end
+    it 'does not exist' do
+      should_list_data_bags
+      nonexistent_child.exists?.should be_false
+    end
+    it 'is not a directory' do
+      should_list_data_bags
+      nonexistent_child.dir?.should be_false
+    end
+    it 'read returns NotFoundError' do
+      expect { nonexistent_child.read }.to raise_error(Chef::ChefFS::FileSystem::NotFoundError)
+    end
+  end
+
+end

data/spec/unit/chef_fs/file_system_spec.rb

@@ -0,0 +1,136 @@
+#
+# Author:: John Keiser (<jkeiser@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 'support/shared/unit/file_system_support'
+require 'chef/chef_fs/file_system'
+require 'chef/chef_fs/file_pattern'
+
+describe Chef::ChefFS::FileSystem do
+  include FileSystemSupport
+
+  context 'with empty filesystem' do
+    let(:fs) { memory_fs('', {}) }
+
+    context 'list' do
+      it '/' do
+        list_should_yield_paths(fs, '/', '/')
+      end
+      it '/a' do
+        list_should_yield_paths(fs, '/a', '/a')
+      end
+      it '/a/b' do
+        list_should_yield_paths(fs, '/a/b')
+      end
+      it '/*' do
+        list_should_yield_paths(fs, '/*', '/')
+      end
+    end
+
+    context 'resolve_path' do
+      it '/' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/').path.should == '/'
+      end
+      it 'nonexistent /a' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/a').path.should == '/a'
+      end
+      it 'nonexistent /a/b' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/a/b').path.should == '/a/b'
+      end
+    end
+  end
+
+  context 'with a populated filesystem' do
+    let(:fs) {
+      memory_fs('', {
+        :a => {
+          :aa => {
+            :c => '',
+            :zz => ''
+          },
+          :ab => {
+            :c => '',
+          }
+        },
+        :x => ''
+      })
+    }
+    context 'list' do
+      it '/**' do
+        list_should_yield_paths(fs, '/**', '/', '/a', '/x', '/a/aa', '/a/aa/c', '/a/aa/zz', '/a/ab', '/a/ab/c')
+      end
+      it '/' do
+        list_should_yield_paths(fs, '/', '/')
+      end
+      it '/*' do
+        list_should_yield_paths(fs, '/*', '/', '/a', '/x')
+      end
+      it '/*/*' do
+        list_should_yield_paths(fs, '/*/*', '/a/aa', '/a/ab')
+      end
+      it '/*/*/*' do
+        list_should_yield_paths(fs, '/*/*/*', '/a/aa/c', '/a/aa/zz', '/a/ab/c')
+      end
+      it '/*/*/?' do
+        list_should_yield_paths(fs, '/*/*/?', '/a/aa/c', '/a/ab/c')
+      end
+      it '/a/*/c' do
+        list_should_yield_paths(fs, '/a/*/c', '/a/aa/c', '/a/ab/c')
+      end
+      it '/**b/c' do
+        list_should_yield_paths(fs, '/**b/c', '/a/ab/c')
+      end
+      it '/a/ab/c' do
+        no_blocking_calls_allowed
+        list_should_yield_paths(fs, '/a/ab/c', '/a/ab/c')
+      end
+      it 'nonexistent /a/ab/blah' do
+        no_blocking_calls_allowed
+        list_should_yield_paths(fs, '/a/ab/blah', '/a/ab/blah')
+      end
+      it 'nonexistent /a/ab/blah/bjork' do
+        no_blocking_calls_allowed
+        list_should_yield_paths(fs, '/a/ab/blah/bjork')
+      end
+    end
+
+    context 'resolve_path' do
+      before(:each) do
+        no_blocking_calls_allowed
+      end
+      it 'resolves /' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/').path.should == '/'
+      end
+      it 'resolves /x' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/x').path.should == '/x'
+      end
+      it 'resolves /a' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/a').path.should == '/a'
+      end
+      it 'resolves /a/aa' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/a/aa').path.should == '/a/aa'
+      end
+      it 'resolves /a/aa/zz' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/a/aa/zz').path.should == '/a/aa/zz'
+      end
+      it 'resolves nonexistent /y/x/w' do
+        Chef::ChefFS::FileSystem.resolve_path(fs, '/y/x/w').path.should == '/y/x/w'
+      end
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -35,17 +35,15 @@ shared_examples_for Chef::Client do
     ohai_data = { :fqdn             => @fqdn,
                   :hostname         => @hostname,
                   :platform         => 'example-platform',
-                  :platform_version => 'example-platform',
+                  :platform_version => 'example-platform-1.0',
                   :data             => {} }
     ohai_data.stub!(:all_plugins).and_return(true)
-    ohai_data.stub!(:data).and_return(ohai_data[:data])
+    ohai_data.stub!(:data).and_return(ohai_data)
     Ohai::System.stub!(:new).and_return(ohai_data)
 
-    @node = Chef::Node.new(@hostname)
+    @node = Chef::Node.new
     @node.name(@fqdn)
     @node.chef_environment("_default")
-    @node[:platform] = "example-platform"
-    @node[:platform_version] = "example-platform-1.0"
 
     @client = Chef::Client.new
     @client.node = @node
@@ -75,6 +73,111 @@ shared_examples_for Chef::Client do
     end
   end
 
+  describe "configuring output formatters" do
+    before do
+      @original_config = Chef::Config.configuration
+    end
+
+    after do
+      Chef::Config.configuration.replace(@original_config)
+    end
+    context "when no formatter has been configured" do
+      before do
+        Chef::Config.formatters.clear
+        @client = Chef::Client.new
+      end
+
+      context "and STDOUT is a TTY" do
+        before do
+          Chef::Config[:force_formatter] = false
+          Chef::Config[:force_logger] = false
+          STDOUT.stub!(:tty?).and_return(true)
+        end
+
+        it "configures the :doc formatter" do
+          @client.formatters_for_run.should == [[:doc]]
+        end
+
+        context "and force_logger is set" do
+          before do
+            Chef::Config[:force_logger] = true
+          end
+
+          it "configures the :null formatter" do
+            Chef::Config[:force_logger].should be_true
+            @client.formatters_for_run.should == [[:null]]
+          end
+
+        end
+
+      end
+
+      context "and STDOUT is not a TTY" do
+        before do
+          Chef::Config[:force_formatter] = false
+          STDOUT.stub!(:tty?).and_return(false)
+        end
+
+        it "configures the :null formatter" do
+          @client.formatters_for_run.should == [[:null]]
+        end
+
+        context "and force_formatter is set" do
+          before do
+            Chef::Config[:force_formatter] = true
+          end
+          it "it configures the :doc formatter" do
+            @client.formatters_for_run.should == [[:doc]]
+          end
+        end
+      end
+
+    end
+
+    context "when a formatter is configured" do
+      context "with no output path" do
+        before do
+          Chef::Config.formatters.clear
+          @client = Chef::Client.new
+          Chef::Config.add_formatter(:min)
+        end
+
+        it "does not configure a default formatter" do
+          @client.formatters_for_run.should == [[:min, nil]]
+        end
+
+        it "configures the formatter for STDOUT/STDERR" do
+          configured_formatters = @client.configure_formatters
+          min_formatter = configured_formatters[0]
+          min_formatter.output.out.should == STDOUT
+          min_formatter.output.err.should == STDERR
+        end
+      end
+
+      context "with an output path" do
+        before do
+          Chef::Config.formatters.clear
+          @client = Chef::Client.new
+          @tmpout = Tempfile.open("rspec-for-client-formatter-selection-#{Process.pid}")
+          Chef::Config.add_formatter(:min, @tmpout.path)
+        end
+
+        after do
+          @tmpout.close unless @tmpout.closed?
+          @tmpout.unlink
+        end
+
+        it "configures the formatter for the file path" do
+          configured_formatters = @client.configure_formatters
+          min_formatter = configured_formatters[0]
+          min_formatter.output.out.path.should == @tmpout.path
+          min_formatter.output.err.path.should == @tmpout.path
+        end
+      end
+
+    end
+  end
+
   describe "run" do
 
     it "should identify the node and run ohai, then register the client" do
@@ -89,10 +192,8 @@ shared_examples_for Chef::Client do
       File.should_receive(:exists?).with(Chef::Config[:client_key]).exactly(1).times.and_return(false)
 
       #   Client.register will register with the validation client name.
-      Chef::REST.should_receive(:new).with(Chef::Config[:client_url], Chef::Config[:validation_client_name], Chef::Config[:validation_key]).exactly(1).and_return(mock_chef_rest_for_client)
-      mock_chef_rest_for_client.should_receive(:register).with(@fqdn, Chef::Config[:client_key]).exactly(1).and_return(true)
+      Chef::ApiClient::Registration.any_instance.should_receive(:run)
       #   Client.register will then turn around create another
-
       #   Chef::REST object, this time with the client key it got from the
       #   previous step.
       Chef::REST.should_receive(:new).with(Chef::Config[:chef_server_url], @fqdn, Chef::Config[:client_key]).exactly(1).and_return(mock_chef_rest_for_node)
@@ -124,11 +225,14 @@ shared_examples_for Chef::Client do
       Chef::REST.should_receive(:new).with(Chef::Config[:chef_server_url]).and_return(mock_chef_rest_for_node_save)
       mock_chef_rest_for_node_save.should_receive(:put_rest).with("nodes/#{@fqdn}", @node).and_return(true)
 
+      Chef::RunLock.any_instance.should_receive(:acquire)
+      Chef::RunLock.any_instance.should_receive(:release)
+
       # Post conditions: check that node has been filled in correctly
       @client.should_receive(:run_started)
       @client.should_receive(:run_completed_successfully)
 
-      if(Chef::Config[:client_fork] && !windows?)
+      if(Chef::Config[:client_fork])
         require 'stringio'
         if(Chef::Config[:pipe_node])
           pipe_sim = StringIO.new
@@ -138,7 +242,6 @@ shared_examples_for Chef::Client do
             res.replace(string)
           end
           pipe_sim.should_receive(:gets).and_return(res)
-          Chef::CouchDB.should_receive(:new).and_return(nil)
           IO.should_receive(:pipe).and_return([pipe_sim, pipe_sim])
           IO.should_receive(:select).and_return(true)
         end
@@ -232,32 +335,13 @@ shared_examples_for Chef::Client do
     end
   end
 
-  describe "should set single lettered environments correctly" do
-    before do
-      @original_env = Chef::Config[:environment]
-    end
-
-    after do
-      Chef::Config[:environment] = @original_env
-    end
-
-    it "should set the environment correctly" do
-      @node.chef_environment.should == "_default"
-      Chef::Config[:environment] = "A"
-
-      @client.build_node
-      
-      @node.chef_environment.should == "A"
-    end
-  end
-
   describe "when a run list override is provided" do
     before do
-      @node = Chef::Node.new(@hostname)
+      @node = Chef::Node.new
       @node.name(@fqdn)
       @node.chef_environment("_default")
-      @node[:platform] = "example-platform"
-      @node[:platform_version] = "example-platform-1.0"
+      @node.automatic_attrs[:platform] = "example-platform"
+      @node.automatic_attrs[:platform_version] = "example-platform-1.0"
     end
 
     it "should permit spaces in overriding run list" do
@@ -302,8 +386,15 @@ describe Chef::Client do
 end
 
 describe "Chef::Client Forked" do
-  it_behaves_like Chef::Client
   before do
+    @original_config = Chef::Config.configuration
     Chef::Config[:client_fork] = true
   end
+
+  after do
+    Chef::Config.configuration.replace(@original_config)
+  end
+
+  it_behaves_like Chef::Client
+
 end