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

data/spec/support/shared/unit/windows_script_resource.rb

@@ -0,0 +1,48 @@
+#
+# Author:: Adam Edwards (<adamed@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 'support/shared/unit/execute_resource'
+require 'support/shared/unit/script_resource'
+
+shared_examples_for "a Windows script resource" 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 = resource_instance
+
+  end  
+
+  it "should be a kind of Chef::Resource::WindowsScript" do
+    @resource.should be_a_kind_of(Chef::Resource)
+    @resource.should be_a_kind_of(Chef::Resource::WindowsScript)
+  end
+
+  context "script" do
+    let(:script_resource) { resource_instance }    
+    it_should_behave_like "a script resource"  
+  end
+  
+end
+

data/spec/tiny_server.rb

@@ -18,6 +18,7 @@
 
 require 'rubygems'
 require 'webrick'
+require 'webrick/https'
 require 'rack'
 #require 'thin'
 require 'singleton'
@@ -90,7 +91,7 @@ module TinyServer
       true
     rescue OpenURI::HTTPError
       true
-    rescue Errno::ECONNREFUSED => e
+    rescue Errno::ECONNREFUSED, EOFError, Errno::ECONNRESET => e
       sleep 0.1
       # If the host has ":::1 localhost" in its hosts file and if IPv6
       # is not enabled we can get NetworkUnreachable exception...
@@ -127,20 +128,20 @@ module TinyServer
       @routes = {GET => [], PUT => [], POST => [], DELETE => []}
     end
 
-    def get(path, response_code, data=nil, &block)
-      @routes[GET] << Route.new(path, Response.new(response_code,data, &block))
+    def get(path, response_code, data=nil, headers=nil, &block)
+      @routes[GET] << Route.new(path, Response.new(response_code, data, headers, &block))
     end
 
-    def put(path, response_code, data=nil, &block)
-      @routes[PUT] << Route.new(path, Response.new(response_code,data, &block))
+    def put(path, response_code, data=nil, headers=nil, &block)
+      @routes[PUT] << Route.new(path, Response.new(response_code, data, headers, &block))
     end
 
-    def post(path, response_code, data=nil, &block)
-      @routes[POST] << Route.new(path, Response.new(response_code,data, &block))
+    def post(path, response_code, data=nil, headers=nil, &block)
+      @routes[POST] << Route.new(path, Response.new(response_code, data, headers, &block))
     end
 
-    def delete(path, response_code, data=nil, &block)
-      @routes[DELETE] << Route.new(path, Response.new(response_code,data, &block))
+    def delete(path, response_code, data=nil, headers=nil, &block)
+      @routes[DELETE] << Route.new(path, Response.new(response_code, data, headers, &block))
     end
 
     def call(env)
@@ -183,14 +184,15 @@ module TinyServer
   class Response
     HEADERS = {'Content-Type' => 'application/json'}
 
-    def initialize(response_code=200,data=nil, &block)
+    def initialize(response_code=200, data=nil, headers=nil, &block)
       @response_code, @data = response_code, data
+      @response_headers = headers ? HEADERS.merge(headers) : HEADERS
       @block = block_given? ? block : nil
     end
 
     def call
       data = @data || @block.call
-      [@response_code, HEADERS, Array(data)]
+      [@response_code, @response_headers, Array(data)]
     end
 
     def to_s

data/spec/unit/api_client/registration_spec.rb

@@ -0,0 +1,172 @@
+#
+# Author:: Daniel DeLeo (<dan@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 'tempfile'
+
+require 'chef/api_client/registration'
+
+describe Chef::ApiClient::Registration do
+  let(:key_location) do
+    make_tmpname("client-registration-key")
+  end
+
+  let(:registration) { Chef::ApiClient::Registration.new("silent-bob", key_location) }
+
+  let :private_key_data do
+    File.open(Chef::Config[:validation_key], "r") {|f| f.read.chomp }
+  end
+
+  before do
+    Chef::Config[:validation_client_name] = "test-validator"
+    Chef::Config[:validation_key] = File.expand_path('ssl/private_key.pem', CHEF_SPEC_DATA)
+  end
+
+  after do
+    File.unlink(key_location) if File.exist?(key_location)
+    Chef::Config[:validation_client_name] = nil
+    Chef::Config[:validation_key] = nil
+  end
+
+  it "has an HTTP client configured with validator credentials" do
+    registration.http_api.should be_a_kind_of(Chef::REST)
+    registration.http_api.client_name.should == "test-validator"
+    registration.http_api.signing_key.should == private_key_data
+  end
+
+  describe "when creating/updating the client on the server" do
+    let(:http_mock) { mock("Chef::REST mock") }
+
+    before do
+      registration.stub!(:http_api).and_return(http_mock)
+    end
+
+    it "creates a new ApiClient on the server using the validator identity" do
+      response = {"uri" => "https://chef.local/clients/silent-bob", 
+                  "private_key" => "--begin rsa key etc--"}
+      http_mock.should_receive(:post).
+        with("clients", :name => 'silent-bob', :admin => false).
+        and_return(response)
+      registration.create_or_update.should == response
+      registration.private_key.should == "--begin rsa key etc--"
+    end
+
+    context "and the client already exists on a Chef 10 server" do
+      it "requests a new key from the server and saves it" do
+        response = {"name" => "silent-bob", "private_key" => "--begin rsa key etc--" }
+
+        response_409 = Net::HTTPConflict.new("1.1", "409", "Conflict")
+        exception_409 = Net::HTTPServerException.new("409 conflict", response_409)
+
+        http_mock.should_receive(:post).and_raise(exception_409)
+        http_mock.should_receive(:put).
+          with("clients/silent-bob", :name => 'silent-bob', :admin => false, :private_key => true).
+          and_return(response)
+        registration.create_or_update.should == response
+        registration.private_key.should == "--begin rsa key etc--"
+      end
+    end
+
+    context "and the client already exists on a Chef 11 server" do
+      it "requests a new key from the server and saves it" do
+        response = Chef::ApiClient.new
+        response.name("silent-bob")
+        response.private_key("--begin rsa key etc--")
+
+        response_409 = Net::HTTPConflict.new("1.1", "409", "Conflict")
+        exception_409 = Net::HTTPServerException.new("409 conflict", response_409)
+
+        http_mock.should_receive(:post).and_raise(exception_409)
+        http_mock.should_receive(:put).
+          with("clients/silent-bob", :name => 'silent-bob', :admin => false, :private_key => true).
+          and_return(response)
+        registration.create_or_update.should == response
+        registration.private_key.should == "--begin rsa key etc--"
+      end
+    end
+  end
+
+  describe "when writing the private key to disk" do
+    before do
+      registration.stub!(:private_key).and_return('--begin rsa key etc--')
+    end
+
+    # Permission read via File.stat is busted on windows, though creating the
+    # file with 0600 has the desired effect of giving access rights to the
+    # owner only. A platform-specific functional test would be helpful.
+    it "creates the file with 0600 permissions", :unix_only do
+      File.should_not exist(key_location)
+      registration.write_key
+      File.should exist(key_location)
+      stat = File.stat(key_location)
+      (stat.mode & 07777).should == 0600
+    end
+
+    it "writes the private key content to the file" do
+      registration.write_key
+      IO.read(key_location).should == "--begin rsa key etc--"
+    end
+  end
+
+  describe "when registering a client" do
+
+    let(:http_mock) { mock("Chef::REST mock") }
+
+    before do
+      registration.stub!(:http_api).and_return(http_mock)
+    end
+
+    it "creates the client on the server and writes the key" do
+      response = {"uri" => "http://chef.local/clients/silent-bob",
+                  "private_key" => "--begin rsa key etc--" }
+      http_mock.should_receive(:post).ordered.and_return(response)
+      registration.run
+      IO.read(key_location).should == "--begin rsa key etc--"
+    end
+
+    it "retries up to 5 times" do
+      response_500 = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
+      exception_500 = Net::HTTPFatalError.new("500 Internal Server Error", response_500)
+
+      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 1
+      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 2
+      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 3
+      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 4
+      http_mock.should_receive(:post).ordered.and_raise(exception_500) # 5
+
+      response = {"uri" => "http://chef.local/clients/silent-bob",
+                  "private_key" => "--begin rsa key etc--" }
+      http_mock.should_receive(:post).ordered.and_return(response)
+      registration.run
+      IO.read(key_location).should == "--begin rsa key etc--"
+    end
+
+    it "gives up retrying after the max attempts" do
+      response_500 = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
+      exception_500 = Net::HTTPFatalError.new("500 Internal Server Error", response_500)
+
+      http_mock.should_receive(:post).exactly(6).times.and_raise(exception_500)
+
+      lambda {registration.run}.should raise_error(Net::HTTPFatalError)
+    end
+
+  end
+
+end
+
+

data/spec/unit/api_client_spec.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -26,128 +26,85 @@ describe Chef::ApiClient do
     @client = Chef::ApiClient.new
   end
 
-  describe "initialize" do
-    it "should be a Chef::ApiClient" do
-      @client.should be_a_kind_of(Chef::ApiClient)
-    end
+  it "has a name attribute" do
+    @client.name("ops_master")
+    @client.name.should == "ops_master"
   end
 
-  describe "name" do
-    it "should let you set the name to a string" do
-      @client.name("ops_master").should == "ops_master"
-    end
-
-    it "should return the current name" do
-      @client.name "ops_master"
-      @client.name.should == "ops_master"
-    end
-
-    it "should not accept spaces" do
-      lambda { @client.name "ops master" }.should raise_error(ArgumentError)
-    end
-
-    it "should throw an ArgumentError if you feed it anything but a string" do
-      lambda { @client.name Hash.new }.should raise_error(ArgumentError)
-    end
+  it "does not allow spaces in the name" do
+    lambda { @client.name "ops master" }.should raise_error(ArgumentError)
   end
 
-  describe "admin" do
-    it "should let you set the admin bit" do
-      @client.admin(true).should == true
-    end
+  it "only allows string values for the name" do
+    lambda { @client.name Hash.new }.should raise_error(ArgumentError)
+  end
 
-    it "should return the current admin value" do
-      @client.admin true 
-      @client.admin.should == true 
-    end
+  it "has an admin flag attribute" do
+    @client.admin(true)
+    @client.admin.should be_true
+  end
 
-    it "should default to false" do
-      @client.admin.should == false
-    end
+  it "defaults to non-admin" do
+    @client.admin.should be_false
+  end
 
-    it "should throw an ArgumentError if you feed it anything but true or false" do
-      lambda { @client.name Hash.new }.should raise_error(ArgumentError)
-    end
+  it "allows only boolean values for the admin flag" do
+    lambda { @client.admin(false) }.should_not raise_error
+    lambda { @client.admin(Hash.new) }.should raise_error(ArgumentError)
   end
 
-  describe "public_key" do
-    it "should let you set the public key" do
-      @client.public_key("super public").should == "super public"
-    end
 
-    it "should return the current public key" do
-      @client.public_key("super public")
-      @client.public_key.should == "super public"
-    end
+  it "has a public key attribute" do
+    @client.public_key("super public")
+    @client.public_key.should == "super public"
+  end
 
-    it "should throw an ArgumentError if you feed it something lame" do
-      lambda { @client.public_key Hash.new }.should raise_error(ArgumentError)
-    end 
+  it "accepts only String values for the public key" do
+    lambda { @client.public_key "" }.should_not raise_error
+    lambda { @client.public_key Hash.new }.should raise_error(ArgumentError)
   end
 
-  describe "private_key" do
-    it "should let you set the private key" do
-      @client.private_key("super private").should == "super private"
-    end
 
-    it "should return the private key" do
-      @client.private_key("super private")
-      @client.private_key.should == "super private"
-    end
+  it "has a private key attribute" do
+    @client.private_key("super private")
+    @client.private_key.should == "super private"
+  end
 
-    it "should throw an ArgumentError if you feed it something lame" do
-      lambda { @client.private_key Hash.new }.should raise_error(ArgumentError)
-    end 
+  it "accepts only String values for the private key" do
+    lambda { @client.private_key "" }.should_not raise_error
+    lambda { @client.private_key Hash.new }.should raise_error(ArgumentError)
   end
 
-  describe "create_keys" do
+  describe "when serializing to JSON" do
     before(:each) do
-      Chef::Certificate.stub!(:gen_keypair).and_return(["cert", "key"])
-    end
-
-    it "should create a certificate based on the client name" do
-      Chef::Certificate.should_receive(:gen_keypair).with(@client.name)
-      @client.create_keys
-    end
-
-    it "should set the private key" do
-      @client.create_keys
-      @client.private_key.should == "key"
+      @client.name("black")
+      @client.public_key("crowes")
+      @json = @client.to_json
     end
 
-    it "should set the public key" do
-      @client.create_keys
-      @client.public_key.should == "cert"
+    it "serializes as a JSON object" do
+      @json.should match(/^\{.+\}$/)
     end
-  end
 
-  describe "serialize" do
-    before(:each) do
-      @client.name("black")
-      @client.public_key("crowes")
-      @client.private_key("monkeypants")
-      @serial = @client.to_json
+    it "includes the name value" do
+      @json.should include(%q{"name":"black"})
     end
 
-    it "should serialize to a json hash" do
-      @client.to_json.should match(/^\{.+\}$/)
+    it "includes the public key value" do
+      @json.should include(%{"public_key":"crowes"})
     end
 
-    %w{
-      name
-      public_key
-    }.each do |t| 
-      it "should include '#{t}'" do
-        @serial.should =~ /"#{t}":"#{@client.send(t.to_sym)}"/
-      end
+    it "includes the 'admin' flag" do
+      @json.should include(%q{"admin":false})
     end
 
-    it "should include 'admin'" do
-      @serial.should =~ /"admin":false/
+    it "includes the private key when present" do
+      @client.private_key("monkeypants")
+      @client.to_json.should include(%q{"private_key":"monkeypants"})
     end
 
-    it "should not include the private key" do
-      @serial.should_not =~ /"private_key":/
+    it "does not include the private key if not present" do
+      @json.should_not include("private_key")
     end
   end
 
@@ -185,6 +142,29 @@ describe Chef::ApiClient do
 
   end
 
+  describe "with correctly configured API credentials" do
+    before do
+      Chef::Config[:node_name] = "silent-bob"
+      Chef::Config[:client_key] = File.expand_path('ssl/private_key.pem', CHEF_SPEC_DATA)
+    end
+
+    after do
+      Chef::Config[:node_name] = nil
+      Chef::Config[:client_key] = nil
+    end
+
+    let :private_key_data do
+      File.open(Chef::Config[:client_key], "r") {|f| f.read.chomp }
+    end
+
+    it "has an HTTP client configured with default credentials" do
+      @client.http_api.should be_a_kind_of(Chef::REST)
+      @client.http_api.client_name.should == "silent-bob"
+      @client.http_api.signing_key.to_s.should == private_key_data
+    end
+  end
+
+
   describe "when requesting a new key" do
     before do
       @http_client = mock("Chef::REST mock")
@@ -196,7 +176,7 @@ describe Chef::ApiClient do
         @a_404_response = Net::HTTPNotFound.new("404 not found and such", nil, nil)
         @a_404_exception = Net::HTTPServerException.new("404 not found exception", @a_404_response)
 
-        @http_client.should_receive(:get_rest).with("clients/lost-my-key").and_raise(@a_404_exception)
+        @http_client.should_receive(:get).with("clients/lost-my-key").and_raise(@a_404_exception)
       end
 
       it "raises a 404 error" do
@@ -208,7 +188,7 @@ describe Chef::ApiClient do
       before do
         @api_client_without_key = Chef::ApiClient.new
         @api_client_without_key.name("lost-my-key")
-        @http_client.should_receive(:get_rest).with("clients/lost-my-key").and_return(@api_client_without_key)
+        @http_client.should_receive(:get).with("clients/lost-my-key").and_return(@api_client_without_key)
       end
 
 
@@ -217,7 +197,7 @@ describe Chef::ApiClient do
           @api_client_with_key = Chef::ApiClient.new
           @api_client_with_key.name("lost-my-key")
           @api_client_with_key.private_key("the new private key")
-          @http_client.should_receive(:put_rest).
+          @http_client.should_receive(:put).
             with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :private_key => true).
             and_return(@api_client_with_key)
         end
@@ -235,7 +215,7 @@ describe Chef::ApiClient do
       context "and the client exists on a Chef 10-like server" do
         before do
           @api_client_with_key = {"name" => "lost-my-key", "private_key" => "the new private key"}
-          @http_client.should_receive(:put_rest).
+          @http_client.should_receive(:put).
             with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :private_key => true).
             and_return(@api_client_with_key)
         end
@@ -251,64 +231,6 @@ describe Chef::ApiClient do
       end
 
     end
-
-    context "and client side key generation is enabled" do
-
-      let(:response) { {"uri"=> "https://example.com/clients/selfgenkeytest-1395958070", "public_key" => "rsa-key-data"} }
-      let(:pkey_in) { IO.read(File.join(CHEF_SPEC_DATA, "ssl/private_key.pem")) }
-
-      let(:generated_key) { OpenSSL::PKey::RSA.new(pkey_in) }
-      let(:generated_public_key) { generated_key.public_key }
-
-      before do
-        @client.name("deadsexy")
-        OpenSSL::PKey::RSA.stub(:generate).and_return(generated_key)
-        Chef::Config.stub(:local_key_generation).and_return true
-      end
-
-      context "and the client doesn't exist" do
-        let(:response) { {"uri"=> "https://example.com/clients/selfgenkeytest-1395958070", "public_key" => "rsa-key-data"} }
-        let(:pkey_in) { IO.read(File.join(CHEF_SPEC_DATA, "ssl/private_key.pem")) }
-
-        let(:generated_key) { OpenSSL::PKey::RSA.new(pkey_in) }
-        let(:generated_public_key) { generated_key.public_key }
-
-        before do
-          @http_client.should_receive(:post_rest).
-            with("clients", :name => "deadsexy", :admin => false, :public_key => generated_public_key.to_pem).
-            and_return(response)
-        end
-
-        it "creates the client with self generated key" do
-          @client.save(true, true)
-          @client.private_key.should == generated_key.to_pem
-        end
-
-      end
-
-      context "and the client already exists" do
-        before do
-          http_conflict_response = Net::HTTPConflict.new("409 blah blah", "409", "409")
-          http_conflict_error = Net::HTTPServerException.new("409 conflict", http_conflict_response)
-
-          @http_client.should_receive(:post_rest).
-            with("clients", :name => "deadsexy", :admin => false, :public_key => generated_public_key.to_pem).
-            and_raise(http_conflict_error)
-
-          @http_client.should_receive(:put_rest).
-            with("clients/deadsexy", :name => "deadsexy", :admin => false, :public_key => generated_public_key.to_pem).
-            and_return(response)
-        end
-
-        it "creates the client with self generated key" do
-          @client.save(true, true)
-          @client.private_key.should == generated_key.to_pem
-        end
-
-      end
-
-    end
-
   end
 end