chef 11.18.12-x86-mingw32 → 12.0.0.alpha.0-x86-mingw32

data/spec/unit/cookbook_loader_spec.rb

@@ -181,7 +181,7 @@ describe Chef::CookbookLoader do
       aa.to_hash["metadata"].recipes.keys.should include("openldap")
       expected_desc = "Main Open LDAP configuration"
       aa.to_hash["metadata"].recipes["openldap"].should == expected_desc
-      raw = Chef::JSONCompat.to_json(aa.to_hash["metadata"].recipes)
+      raw = aa.to_hash["metadata"].recipes.to_json
       search_str = "\"openldap\":\""
       key_idx = raw.index(search_str)
       key_idx.should be > 0

data/spec/unit/cookbook_uploader_spec.rb

@@ -0,0 +1,160 @@
+#
+# Author:: Daniel DeLeo (<dan@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::CookbookUploader do
+
+  let(:http_client) { double("Chef::REST") }
+
+  let(:cookbook_loader) do
+    loader = Chef::CookbookLoader.new(File.join(CHEF_SPEC_DATA, "cookbooks"))
+    loader.load_cookbooks
+    loader
+  end
+
+  let(:apache2_cookbook) { cookbook_loader.cookbooks_by_name["apache2"] }
+
+  let(:java_cookbook) { cookbook_loader.cookbooks_by_name["java"] }
+
+  let(:cookbooks_to_upload) { [apache2_cookbook, java_cookbook] }
+
+  let(:checksums_of_cookbook_files) { apache2_cookbook.checksums.merge(java_cookbook.checksums) }
+
+  let(:checksums_set) do
+    checksums_of_cookbook_files.keys.inject({}) do |set, cksum|
+      set[cksum] = nil
+      set
+    end
+  end
+
+  let(:sandbox_commit_uri) { "https://chef.example.org/sandboxes/abc123" }
+
+  let(:uploader) { described_class.new(cookbooks_to_upload, :rest => http_client) }
+
+  it "has a list of cookbooks to upload" do
+    expect(uploader.cookbooks).to eq(cookbooks_to_upload)
+  end
+
+  it "creates an HTTP client with default configuration when not initialized with one" do
+    default_http_client = double("Chef::REST")
+    expect(Chef::REST).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(default_http_client)
+    uploader = described_class.new(cookbooks_to_upload)
+    expect(uploader.rest).to eq(default_http_client)
+  end
+
+  describe "uploading cookbooks" do
+
+    def url_for(cksum)
+      "https://storage.example.com/#{cksum}" 
+    end
+
+    let(:sandbox_response) do
+      sandbox_checksums = cksums_not_on_remote.inject({}) do |cksum_map, cksum|
+        cksum_map[cksum] = { "needs_upload" => true, "url" => url_for(cksum)}
+        cksum_map
+      end
+      { "checksums" => sandbox_checksums, "uri" => sandbox_commit_uri }
+    end
+
+    def expect_sandbox_create
+      expect(http_client).to receive(:post).
+        with("sandboxes", {:checksums => checksums_set}).
+        and_return(sandbox_response)
+    end
+
+    def expect_checksum_upload
+      checksums_of_cookbook_files.each do |md5, file_path|
+        next unless cksums_not_on_remote.include?(md5)
+
+        upload_headers = {
+          "content-type" => "application/x-binary",
+          "content-md5"  => an_instance_of(String),
+          "accept"       => "application/json"
+        }
+
+        expect(http_client).to receive(:put).
+          with(url_for(md5), IO.binread(file_path), upload_headers)
+
+      end
+    end
+
+    def expect_sandbox_commit
+      expect(http_client).to receive(:put).with(sandbox_commit_uri, {:is_completed => true})
+    end
+
+    def expect_cookbook_create
+      cookbooks_to_upload.each do |cookbook|
+
+        expect(http_client).to receive(:put).
+          with(cookbook.save_url, cookbook)
+
+      end
+    end
+
+    context "when no files exist on the server" do
+
+      let(:cksums_not_on_remote) do
+        checksums_of_cookbook_files.keys
+      end
+
+      it "uploads all files in a sandbox transaction, then creates cookbooks on the server" do
+        expect_sandbox_create
+        expect_checksum_upload
+        expect_sandbox_commit
+        expect_cookbook_create
+
+        uploader.upload_cookbooks
+      end
+
+    end
+
+    context "when some files exist on the server" do
+
+      let(:cksums_not_on_remote) do
+        checksums_of_cookbook_files.keys[0, 1]
+      end
+
+      it "uploads all files in a sandbox transaction, then creates cookbooks on the server" do
+        expect_sandbox_create
+        expect_checksum_upload
+        expect_sandbox_commit
+        expect_cookbook_create
+
+        uploader.upload_cookbooks
+      end
+
+    end
+
+    context "when all files already exist on the server" do
+
+      let(:cksums_not_on_remote) { [] }
+
+      it "uploads all files in a sandbox transaction, then creates cookbooks on the server" do
+        expect_sandbox_create
+        expect_checksum_upload
+        expect_sandbox_commit
+        expect_cookbook_create
+
+        uploader.upload_cookbooks
+      end
+
+    end
+  end
+
+end

data/spec/unit/cookbook_version_spec.rb

@@ -420,10 +420,6 @@ describe Chef::CookbookVersion do
       end
     end
 
-    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
-      let(:subject) { Chef::CookbookVersion.new("tatft", '/tmp/blah') }
-    end
-
   end
 
 end

data/spec/unit/data_bag_item_spec.rb

@@ -166,7 +166,7 @@ describe Chef::DataBagItem do
     before(:each) do
       @data_bag_item.data_bag('mars_volta')
       @data_bag_item.raw_data = { "id" => "octahedron", "snooze" => { "finally" => :world_will }}
-      @deserial = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@data_bag_item))
+      @deserial = Chef::JSONCompat.from_json(@data_bag_item.to_json)
     end
 
     it "should deserialize to a Chef::DataBagItem object" do
@@ -184,10 +184,6 @@ describe Chef::DataBagItem do
     it "should have a matching 'snooze' key" do
       @deserial["snooze"].should == { "finally" => "world_will" }
     end
-
-    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
-      let(:subject) { @data_bag_item }
-    end
   end
 
   describe "when converting to a string" do

data/spec/unit/data_bag_spec.rb

@@ -58,7 +58,7 @@ describe Chef::DataBag do
   describe "deserialize" do
     before(:each) do
       @data_bag.name('mars_volta')
-      @deserial = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@data_bag))
+      @deserial = Chef::JSONCompat.from_json(@data_bag.to_json)
     end
 
     it "should deserialize to a Chef::DataBag object" do
@@ -73,10 +73,6 @@ describe Chef::DataBag do
       end
     end
 
-    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
-      let(:subject) { @data_bag }
-    end
-
   end
 
   describe "when saving" do

data/spec/unit/deprecation_spec.rb

@@ -46,7 +46,7 @@ describe Chef::Deprecation do
   end
 
   method_snapshot_file = File.join(CHEF_SPEC_DATA, "file-providers-method-snapshot-chef-11-4.json")
-  method_snapshot = Chef::JSONCompat.parse(File.open(method_snapshot_file).read())
+  method_snapshot = JSON.parse(File.open(method_snapshot_file).read())
 
   method_snapshot.each do |class_name, old_methods|
     class_object = class_from_string(class_name)

data/spec/unit/dsl/recipe_spec.rb

@@ -46,6 +46,18 @@ describe Chef::DSL::Recipe do
     it "responds to recipe_name" do
       expect(recipe.recipe_name).to eq(recipe_name)
     end
+
+    it "responds to shell_out" do
+      expect(recipe.respond_to?(:shell_out)).to be true
+    end
+
+    it "responds to shell_out" do
+      expect(recipe.respond_to?(:shell_out!)).to be true
+    end
+
+    it "responds to shell_out" do
+      expect(recipe.respond_to?(:shell_out_with_systems_locale)).to be true
+    end
   end
 
   context "when included in a class that defines the required interface directly" do

data/spec/unit/encrypted_data_bag_item_spec.rb

@@ -100,17 +100,6 @@ describe Chef::EncryptedDataBagItem::Decryptor do
   let(:plaintext_data) { {"foo" => "bar"} }
   let(:encryption_key) { "passwd" }
   let(:decryption_key) { encryption_key }
-  let(:json_wrapped_data) {  Chef::JSONCompat.to_json({"json_wrapper" => plaintext_data}) }
-
-  shared_examples "decryption examples" do
-    it "decrypts the encrypted value" do
-      decryptor.decrypted_data.should eq(json_wrapped_data)
-    end
-
-    it "unwraps the encrypted data and returns it" do
-      decryptor.for_decrypted_item.should eq plaintext_data
-    end
-  end
 
   context "when decrypting a version 2 (JSON+aes-256-cbc+hmac-sha256+random iv) encrypted value" do
     let(:encrypted_value) do
@@ -123,8 +112,6 @@ describe Chef::EncryptedDataBagItem::Decryptor do
       Base64.encode64(raw_hmac)
     end
 
-    include_examples "decryption examples"
-
     it "rejects the data if the hmac is wrong" do
       encrypted_value["hmac"] = bogus_hmac
       lambda { decryptor.for_decrypted_item }.should raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
@@ -147,7 +134,13 @@ describe Chef::EncryptedDataBagItem::Decryptor do
       decryptor.should be_a_kind_of Chef::EncryptedDataBagItem::Decryptor::Version1Decryptor
     end
 
-    include_examples "decryption examples"
+    it "decrypts the encrypted value" do
+      decryptor.decrypted_data.should eq({"json_wrapper" => plaintext_data}.to_json)
+    end
+
+    it "unwraps the encrypted data and returns it" do
+      decryptor.for_decrypted_item.should eq plaintext_data
+    end
 
     describe "and the decryption step returns invalid data" do
       it "raises a decryption failure error" do

data/spec/unit/environment_spec.rb

@@ -196,7 +196,7 @@ describe Chef::Environment do
 
     %w{name description cookbook_versions}.each do |t|
       it "should include '#{t}'" do
-        @json.should =~ /"#{t}":#{Regexp.escape(Chef::JSONCompat.to_json(@environment.send(t.to_sym)))}/
+        @json.should =~ /"#{t}":#{Regexp.escape(@environment.send(t.to_sym).to_json)}/
       end
     end
 
@@ -207,10 +207,6 @@ describe Chef::Environment do
     it "should include 'chef_type'" do
       @json.should =~ /"chef_type":"environment"/
     end
-
-    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
-      let(:subject) { @environment }
-    end
   end
 
   describe "from_json" do
@@ -226,7 +222,7 @@ describe Chef::Environment do
         "json_class" => "Chef::Environment",
         "chef_type" => "environment"
       }
-      @environment = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@data))
+      @environment = Chef::JSONCompat.from_json(@data.to_json)
     end
 
     it "should return a Chef::Environment" do
@@ -424,7 +420,7 @@ describe Chef::Environment do
           "description" => "desc",
           "chef_type" => "environment"
         }
-        IO.should_receive(:read).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(Chef::JSONCompat.to_json(environment_hash))
+        IO.should_receive(:read).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(JSON.dump(environment_hash))
         environment = Chef::Environment.load('foo')
 
         environment.should be_a_kind_of(Chef::Environment)

data/spec/unit/exceptions_spec.rb

@@ -74,11 +74,5 @@ describe Chef::Exceptions do
     it "should have an exception class of #{exception} which inherits from #{expected_super_class}" do
       lambda{ raise exception }.should raise_error(expected_super_class)
     end
-
-    if exception.methods.include?(:to_json)
-      include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
-        let(:subject) { exception }
-      end
-    end
   end
 end

data/spec/unit/http/json_input_spec.rb

@@ -0,0 +1,128 @@
+#--
+# Author:: Daniel DeLeo (<dan@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'
+require 'chef/http/json_input'
+
+describe Chef::HTTP::JSONInput do
+
+  let(:json_encoder) { described_class.new() }
+
+  let(:url) { URI.parse("http://example.com") }
+  let(:headers) { {} }
+
+  def handle_request
+    json_encoder.handle_request(http_method, url, headers, data)
+  end
+
+  it "passes the response unmodified" do
+    http_response = double("Net::HTTPSuccess")
+    request = double("Chef::HTTP::HTTPRequest")
+    return_value = "response body"
+
+    result = json_encoder.handle_response(http_response, request, return_value)
+    expect(result).to eq([http_response, request, return_value])
+  end
+
+  it "doesn't handle streaming responses" do
+    http_response = double("Net::HTTPSuccess")
+    expect(json_encoder.stream_response_handler(http_response)).to be nil
+  end
+
+  it "does nothing for stream completion" do
+    http_response = double("Net::HTTPSuccess")
+    request = double("Chef::HTTP::HTTPRequest")
+    return_value = "response body"
+
+    result = json_encoder.handle_response(http_response, request, return_value)
+    expect(result).to eq([http_response, request, return_value])
+  end
+
+  context "when handling a request with no body" do
+
+    let(:http_method) { :get }
+    let(:data) { nil }
+
+    it "passes the request unmodified" do
+      expect(handle_request).to eq([http_method, url, headers, data])
+    end
+  end
+
+  context "when the request should be serialized" do
+
+    let(:http_method) { :put }
+    let(:data) { {foo: "bar"} }
+    let(:expected_data) { %q[{"foo":"bar"}] }
+
+    context "and the request has a ruby object as the body and no explicit content-type" do
+
+      it "serializes the body to json" do
+        # Headers Hash get mutated, so we start by asserting it's empty:
+        expect(headers).to be_empty
+
+        expect(handle_request).to eq([http_method, url, headers, expected_data])
+
+        # Now the headers Hash should have json content type:
+        expect(headers).to have_key("Content-Type")
+        expect(headers["Content-Type"]).to eq("application/json")
+      end
+    end
+
+    context "ant the request has an explicit content type of json" do
+
+      it "serializes the body to json when content-type is all lowercase" do
+        headers["content-type"] = "application/json"
+
+        expect(handle_request).to eq([http_method, url, headers, expected_data])
+
+        # Content-Type header should be normalized:
+        expect(headers.size).to eq(1)
+        expect(headers).to have_key("Content-Type")
+        expect(headers["Content-Type"]).to eq("application/json")
+      end
+
+    end
+
+  end
+
+  context "when handling a request with an explicit content type other than json" do
+
+    let(:http_method) { :put }
+    let(:data) { "some arbitrary bytes" }
+
+    it "does not serialize the body to json when content type is given as lowercase" do
+      headers["content-type"] = "application/x-binary"
+
+      expect(handle_request).to eq([http_method, url, headers, data])
+
+      # not normalized
+      expect(headers).to eq({"content-type" => "application/x-binary"})
+    end
+
+    it "does not serialize the body to json when content type is given in capitalized form" do
+      headers["Content-Type"] = "application/x-binary"
+
+      expect(handle_request).to eq([http_method, url, headers, data])
+
+      # not normalized
+      expect(headers).to eq({"Content-Type" => "application/x-binary"})
+    end
+
+  end
+
+end