chef 11.12.0.alpha.1-x86-mingw32 → 11.12.0.rc.1-x86-mingw32

data/spec/unit/application/client_spec.rb

@@ -127,7 +127,7 @@ describe Chef::Application::Client, "configure_chef" do
 end
 
 describe Chef::Application::Client, "run_application", :unix_only do
-  before do
+  before(:each) do
     @pipe = IO.pipe
     @app = Chef::Application::Client.new
     @app.stub(:run_chef_client) do
@@ -147,4 +147,51 @@ describe Chef::Application::Client, "run_application", :unix_only do
     IO.select([@pipe[0]], nil, nil, 0).should_not be_nil
     @pipe[0].gets.should == "finished\n"
   end
+
+  describe "when splay is set" do
+    before do
+      Chef::Config[:splay] = 10
+      Chef::Config[:interval] = 10
+
+      run_count = 0
+
+      # uncomment to debug failures...
+      # Chef::Log.init($stderr)
+      # Chef::Log.level = :debug
+
+      @app.stub(:run_chef_client) do
+
+        run_count += 1
+        if run_count > 3
+          exit 0
+        end
+
+        # If everything is fine, sending USR1 to self should prevent
+        # app to go into splay sleep forever.
+        Process.kill("USR1", Process.pid)
+      end
+
+      number_of_sleep_calls = 0
+
+      # This is a very complicated way of writing
+      # @app.should_receive(:sleep).once.
+      # We have to do it this way because the main loop of
+      # Chef::Application::Client swallows most exceptions, and we need to be
+      # able to expose our expectation failures to the parent process in the test.
+      @app.stub(:sleep) do |arg|
+        number_of_sleep_calls += 1
+        if number_of_sleep_calls > 1
+          exit 127
+        end
+      end
+    end
+
+    it "shouldn't sleep when sent USR1" do
+      pid = fork do
+        @app.run_application
+      end
+      _pid, result = Process.waitpid2(pid)
+      result.exitstatus.should == 0
+    end
+  end
 end

data/spec/unit/cookbook/chefignore_spec.rb

@@ -36,4 +36,14 @@ describe Chef::Cookbook::Chefignore do
     @chefignore.ignored?('recipes/ignoreme.rb').should be_true
     @chefignore.ignored?('recipes/dontignoreme.rb').should be_false
   end
+
+  context "when using the single cookbook pattern" do
+    before do
+      @chefignore = Chef::Cookbook::Chefignore.new(File.join(CHEF_SPEC_DATA, 'standalone_cookbook'))
+    end
+
+    it "loads the globs in the chefignore file" do
+      @chefignore.ignores.should =~ %w[recipes/ignoreme.rb ignored vendor/bundle/*]
+    end
+  end
 end

data/spec/unit/cookbook/metadata_spec.rb

@@ -402,7 +402,7 @@ describe Chef::Cookbook::Metadata do
       @meta.attributes["db/mysql/databases"][:recipes].should == []
     end
 
-    it "should allow the default value to be a string, array, or hash" do
+    it "should allow the default value to be a string, array, hash, boolean or numeric" do
       lambda {
         @meta.attribute("db/mysql/databases", :default => [])
       }.should_not raise_error
@@ -412,11 +412,55 @@ describe Chef::Cookbook::Metadata do
       lambda {
         @meta.attribute("db/mysql/databases", :default => "alice in chains")
       }.should_not raise_error
+      lambda {
+        @meta.attribute("db/mysql/databases", :default => 1337)
+      }.should_not raise_error
+      lambda {
+        @meta.attribute("db/mysql/databases", :default => true)
+      }.should_not raise_error
       lambda {
         @meta.attribute("db/mysql/databases", :required => :not_gonna_do_it)
       }.should raise_error(ArgumentError)
     end
 
+    it "should limit the types allowed in the choice array" do
+      options = {
+        :type => "string",
+        :choice => [ "test1", "test2" ],
+        :default => "test1"
+      }
+      lambda {
+        @meta.attribute("test_cookbook/test", options)
+      }.should_not raise_error
+  
+      options = {
+        :type => "boolean",
+        :choice => [ true, false ],
+        :default => true
+      }
+      lambda {
+        @meta.attribute("test_cookbook/test", options)
+      }.should_not raise_error
+
+      options = {
+        :type => "numeric",
+        :choice => [ 1337, 420 ],
+        :default => 1337
+      }
+      lambda {
+        @meta.attribute("test_cookbook/test", options)
+      }.should_not raise_error
+
+      options = {
+        :type => "numeric",
+        :choice => [ true, "false" ],
+        :default => false
+      }
+      lambda {
+        @meta.attribute("test_cookbook/test", options)
+      }.should raise_error
+    end
+
     it "should error if default used with calculated" do
       lambda {
         attrs = {

data/spec/unit/cookbook/syntax_check_spec.rb

@@ -24,6 +24,17 @@ describe Chef::Cookbook::SyntaxCheck do
   let(:cookbook_path) { File.join(CHEF_SPEC_DATA, 'cookbooks', 'openldap') }
   let(:syntax_check) { Chef::Cookbook::SyntaxCheck.new(cookbook_path) }
 
+  let(:open_ldap_cookbook_files) {
+    %w{ attributes/default.rb 
+        attributes/smokey.rb
+        definitions/client.rb
+        definitions/server.rb
+        metadata.rb
+        recipes/default.rb
+        recipes/gigantor.rb
+        recipes/one.rb }.map{ |f| File.join(cookbook_path, f) }
+}
+
   before do
     Chef::Log.logger = Logger.new(StringIO.new)
     Chef::Log.level = :warn # suppress "Syntax OK" messages
@@ -47,6 +58,23 @@ describe Chef::Cookbook::SyntaxCheck do
     Chef::Config[:cookbook_path] = File.dirname(cookbook_path)
     syntax_check = Chef::Cookbook::SyntaxCheck.for_cookbook(:openldap)
     syntax_check.cookbook_path.should == cookbook_path
+    syntax_check.ruby_files.sort.should == open_ldap_cookbook_files.sort
+  end
+
+  it "creates a syntax checker given the cookbook name and cookbook_path" do
+    syntax_check = Chef::Cookbook::SyntaxCheck.for_cookbook(:openldap, File.join(CHEF_SPEC_DATA, 'cookbooks'))
+    syntax_check.cookbook_path.should == cookbook_path
+    syntax_check.ruby_files.sort.should == open_ldap_cookbook_files.sort
+  end
+
+  context "when using a standalone cookbook" do
+    let(:cookbook_path) { File.join(CHEF_SPEC_DATA, 'standalone_cookbook') }
+
+    it "creates a syntax checker given the cookbook name and cookbook_path for a standalone cookbook" do
+      syntax_check = Chef::Cookbook::SyntaxCheck.for_cookbook(:standalone_cookbook, CHEF_SPEC_DATA)
+      syntax_check.cookbook_path.should == cookbook_path
+      syntax_check.ruby_files.should == [File.join(cookbook_path, 'recipes/default.rb')]
+    end
   end
 
   describe "when first created" do

data/spec/unit/cookbook_spec.rb

@@ -68,16 +68,6 @@ describe Chef::CookbookVersion do
     @cookbook.preferred_filename(@node, :files, 'a-filename', 'the-checksum').should be_nil
   end
 
-  it "should allow you to include a fully-qualified recipe using the DSL" do
-    # DSL method include_recipe allows multiple arguments, so extract the first
-    @node.should_receive(:loaded_recipe).with(:openldap, "gigantor")
-    recipe = @run_context.include_recipe("openldap::gigantor").first
-
-    recipe.recipe_name.should == "gigantor"
-    recipe.cookbook_name.should == :openldap
-    @run_context.resource_collection[0].name.should == "blanket"
-  end
-
   it "should raise an ArgumentException if you try to load a bad recipe name" do
     lambda { @cookbook.load_recipe("doesnt_exist", @node) }.should raise_error(ArgumentError)
   end

data/spec/unit/guard_interpreter/resource_guard_interpreter_spec.rb

@@ -0,0 +1,56 @@
+#
+# Author:: Adam Edwards (<adamed@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, 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::GuardInterpreter::ResourceGuardInterpreter 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.new("powershell_unit_test", run_context)
+    @resource.stub(:run_action)
+    @resource.stub(:updated).and_return(true)
+  end
+
+  describe "when evaluating a guard resource" do
+    let(:resource) { @resource }
+
+    it "should allow guard interpreter to be set to Chef::Resource::Script" do
+      resource.guard_interpreter(:script)
+      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(false)
+      resource.only_if("echo hi")
+    end
+    
+    it "should allow guard interpreter to be set to Chef::Resource::PowershellScript derived indirectly from Chef::Resource::Script" do
+      resource.guard_interpreter(:powershell_script)
+      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(false)
+      resource.only_if("echo hi")
+    end
+    
+    it "should raise an exception if guard_interpreter is set to a resource not derived from Chef::Resource::Script" do
+      resource.guard_interpreter(:file)
+      expect { resource.only_if("echo hi") }.to raise_error ArgumentError
+    end
+  end
+end
+

data/spec/unit/http/simple_spec.rb

@@ -0,0 +1,32 @@
+#
+# Author:: Serdar Sutay (<serdar@opscode.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, 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::HTTP::Simple do
+  it "should have content length validation middleware after compressor middleware" do
+    client = Chef::HTTP::Simple.new("dummy.com")
+    middlewares = client.instance_variable_get(:@middlewares)
+    content_length = middlewares.find_index { |e| e.is_a? Chef::HTTP::ValidateContentLength }
+    decompressor = middlewares.find_index { |e| e.is_a? Chef::HTTP::Decompressor }
+
+    content_length.should_not be_nil
+    decompressor.should_not be_nil
+    (decompressor < content_length).should be_true
+  end
+end

data/spec/unit/http/validate_content_length_spec.rb

@@ -0,0 +1,187 @@
+#
+# Author:: Serdar Sutay (<serdar@opscode.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, 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 'stringio'
+
+describe Chef::HTTP::ValidateContentLength do
+  class TestClient < Chef::HTTP
+    use Chef::HTTP::ValidateContentLength
+  end
+
+  let(:method) { "GET" }
+  let(:url) { "http://dummy.com" }
+  let(:headers) { {} }
+  let(:data) { false }
+
+  let(:request) { }
+  let(:return_value) { "200" }
+
+  # Test Variables
+  let(:request_type) { :streaming }
+  let(:content_length_value) { 23 }
+  let(:streaming_length) { 23 }
+  let(:response_body) { "Thanks for checking in." }
+  let(:response_headers) {
+    {
+      "content-length" => content_length_value
+    }
+  }
+
+  let(:response) {
+    m = double('HttpResponse', :body => response_body)
+    m.stub(:[]) do |key|
+      response_headers[key]
+    end
+
+    m
+  }
+
+  let(:middleware) {
+    client = TestClient.new(url)
+    client.middlewares[0]
+  }
+
+  def run_content_length_validation
+    stream_handler = middleware.stream_response_handler(response)
+    middleware.handle_request(method, url, headers, data)
+
+    case request_type
+    when :streaming
+      # First stream the data
+      data_length = streaming_length
+      while data_length > 0
+        chunk_size = data_length > 10 ? 10 : data_length
+        stream_handler.handle_chunk(double("Chunk", :bytesize => chunk_size))
+        data_length -= chunk_size
+      end
+
+      # Finally call stream complete
+      middleware.handle_stream_complete(response, request, return_value)
+    when :direct
+      middleware.handle_response(response, request, return_value)
+    else
+      raise "Unknown request_type: #{request_type}"
+    end
+  end
+
+  let(:debug_stream) { StringIO.new }
+  let(:debug_output) { debug_stream.string }
+
+  before(:each) {
+    Chef::Log.level = :debug
+    Chef::Log.stub(:debug) do |message|
+      debug_stream.puts message
+    end
+  }
+
+  describe "without response body" do
+    let(:request_type) { :direct }
+    let(:response_body) { "Thanks for checking in." }
+
+    it "shouldn't raise error" do
+      lambda { run_content_length_validation }.should_not raise_error
+    end
+  end
+
+  describe "without Content-Length header" do
+    let(:response_headers) { { } }
+
+    [ "direct", "streaming" ].each do |req_type|
+      describe "when running #{req_type} request" do
+        let(:request_type) { req_type.to_sym }
+
+        it "should skip validation and log for debug" do
+          run_content_length_validation
+          debug_output.should include("HTTP server did not include a Content-Length header in response")
+        end
+      end
+    end
+  end
+
+  describe "with correct Content-Length header" do
+    [ "direct", "streaming" ].each do |req_type|
+      describe "when running #{req_type} request" do
+        let(:request_type) { req_type.to_sym }
+
+        it "should validate correctly" do
+          run_content_length_validation
+          debug_output.should include("Content-Length validated correctly.")
+        end
+      end
+    end
+  end
+
+  describe "with wrong Content-Length header" do
+    let(:content_length_value) { 25 }
+    [ "direct", "streaming" ].each do |req_type|
+      describe "when running #{req_type} request" do
+        let(:request_type) { req_type.to_sym }
+
+        it "should raise ContentLengthMismatch error" do
+          lambda { run_content_length_validation }.should raise_error(Chef::Exceptions::ContentLengthMismatch)
+        end
+      end
+    end
+  end
+
+  describe "when download is interrupted" do
+    let(:streaming_length) { 12 }
+
+    it "should raise ContentLengthMismatch error" do
+      lambda { run_content_length_validation }.should raise_error(Chef::Exceptions::ContentLengthMismatch)
+    end
+  end
+
+  describe "when Transfer-Encoding & Content-Length is set" do
+    let(:response_headers) {
+      {
+        "content-length" => content_length_value,
+        "transfer-encoding" => "chunked"
+      }
+    }
+
+    [ "direct", "streaming" ].each do |req_type|
+      describe "when running #{req_type} request" do
+        let(:request_type) { req_type.to_sym }
+
+        it "should skip validation and log for debug" do
+          run_content_length_validation
+          debug_output.should include("Transfer-Encoding header is set, skipping Content-Length check.")
+        end
+      end
+    end
+  end
+
+  describe "when client is being reused" do
+    before do
+      run_content_length_validation
+      debug_output.should include("Content-Length validated correctly.")
+    end
+
+    it "should reset internal counter" do
+        middleware.instance_variable_get(:@content_length_counter).should be_nil
+    end
+
+    it "should validate correctly second time" do
+      run_content_length_validation
+      debug_output.should include("Content-Length validated correctly.")
+    end
+  end
+
+end