chef 10.12.0 → 10.14.0.beta.1

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

@@ -0,0 +1,180 @@
+#
+# 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.
+#
+
+
+
+# == API Error Inspector Examples
+# These tests are work in progress. They exercise the code enough to ensure it
+# runs without error, but don't make assertions about the output. This is
+# because aspects such as how information gets formatted, what's included, etc.
+# are still in flux. When testing an inspector, change the outputter to use
+# STDOUT and manually check the ouput.
+
+shared_examples_for "an api error inspector" do
+
+  before do
+    @node_name = "test-node.example.com"
+    @config = {
+      :validation_client_name => "testorg-validator",
+      :validation_key => "/etc/chef/testorg-validator.pem",
+      :chef_server_url => "https://chef-api.example.com",
+      :node_name => "testnode-name",
+      :client_key => "/etc/chef/client.pem"
+    }
+    @description = Chef::Formatters::ErrorDescription.new("Error registering the node:")
+    @outputter = Chef::Formatters::Outputter.new(StringIO.new, STDERR)
+    #@outputter = Chef::Formatters::Outputter.new(STDOUT, STDERR)
+
+  end
+
+  describe "when explaining a network error" do
+    before do
+      @exception = Errno::ECONNREFUSED.new("connection refused")
+      @inspector = described_class.new(@node_name, @exception, @config)
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a nice message" do
+      @description.display(@outputter)
+    end
+
+  end
+
+  describe "when explaining a 'private key missing' error" do
+    before do
+      @exception = Chef::Exceptions::PrivateKeyMissing.new("no private key yo")
+      @inspector = described_class.new(@node_name, @exception, @config)
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a nice message" do
+      @description.display(@outputter)
+    end
+
+  end
+
+  describe "when explaining a 401 caused by clock skew" do
+    before do
+      @response_body = "synchronize the clock on your host"
+      @response = Net::HTTPUnauthorized.new("1.1", "401", "(response) unauthorized")
+      @response.stub!(:body).and_return(@response_body)
+      @exception = Net::HTTPServerException.new("(exception) unauthorized", @response)
+      @inspector = described_class.new(@node_name, @exception, @config)
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a nice message" do
+      @description.display(@outputter)
+    end
+
+  end
+
+  describe "when explaining a 401 (no clock skew)" do
+    before do
+      @response_body = "check your key and node name"
+      @response = Net::HTTPUnauthorized.new("1.1", "401", "(response) unauthorized")
+      @response.stub!(:body).and_return(@response_body)
+      @exception = Net::HTTPServerException.new("(exception) unauthorized", @response)
+      @inspector = described_class.new(@node_name, @exception, @config)
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a nice message" do
+      @description.display(@outputter)
+    end
+
+  end
+
+  describe "when explaining a 403" do
+    before do
+      @response_body = "forbidden"
+      @response = Net::HTTPForbidden.new("1.1", "403", "(response) forbidden")
+      @response.stub!(:body).and_return(@response_body)
+      @exception = Net::HTTPServerException.new("(exception) forbidden", @response)
+      @inspector = described_class.new(@node_name, @exception, @config)
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a nice message" do
+      @description.display(@outputter)
+    end
+
+  end
+
+  describe "when explaining a 400" do
+    before do
+      @response_body = "didn't like your data"
+      @response = Net::HTTPBadRequest.new("1.1", "400", "(response) bad request")
+      @response.stub!(:body).and_return(@response_body)
+      @exception = Net::HTTPServerException.new("(exception) bad request", @response)
+      @inspector = described_class.new(@node_name, @exception, @config)
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a nice message" do
+      @description.display(@outputter)
+    end
+
+  end
+
+  describe "when explaining a 404" do
+    before do
+      @response_body = "probably caused by a redirect to a get"
+      @response = Net::HTTPNotFound.new("1.1", "404", "(response) not found")
+      @response.stub!(:body).and_return(@response_body)
+      @exception = Net::HTTPServerException.new("(exception) not found", @response)
+      @inspector = described_class.new(@node_name, @exception, @config)
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a nice message" do
+      @description.display(@outputter)
+    end
+  end
+
+  describe "when explaining a 500" do
+    before do
+      @response_body = "sad trombone"
+      @response = Net::HTTPInternalServerError.new("1.1", "500", "(response) internal server error")
+      @response.stub!(:body).and_return(@response_body)
+      @exception = Net::HTTPFatalError.new("(exception) internal server error", @response)
+      @inspector = described_class.new(@node_name, @exception, @config)
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a nice message" do
+      @description.display(@outputter)
+    end
+  end
+
+  describe "when explaining a 503" do
+    before do
+      @response_body = "sad trombone orchestra"
+      @response = Net::HTTPBadGateway.new("1.1", "502", "(response) bad gateway")
+      @response.stub!(:body).and_return(@response_body)
+      @exception = Net::HTTPFatalError.new("(exception) bad gateway", @response)
+      @inspector = described_class.new(@node_name, @exception, @config)
+      @inspector.add_explanation(@description)
+    end
+
+    it "prints a nice message" do
+      @description.display(@outputter)
+    end
+  end
+
+end

data/spec/tiny_server.rb

@@ -0,0 +1,179 @@
+#
+# 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 'rubygems'
+require 'rack'
+require 'thin'
+require 'singleton'
+require 'chef/json_compat'
+require 'open-uri'
+
+module TinyServer
+
+  class Server < Rack::Server
+
+    attr_writer :app
+
+    def self.run(options=nil, &block)
+      tiny_app = new(options)
+      app_code = Rack::Builder.new(&block).to_app
+      tiny_app.app = app_code
+      tiny_app.start
+    end
+  end
+
+  class Manager
+
+    DEFAULT_OPTIONS = {:server => 'thin', :Port => 9000, :Host => 'localhost', :environment => :none}
+
+    def initialize(options=nil)
+      @options = options ? DEFAULT_OPTIONS.merge(options) : DEFAULT_OPTIONS
+      @creator = caller.first
+
+      Thin::Logging.silent = !@options[:debug]
+    end
+
+    def start
+      @server_thread = Thread.new do
+        @server = Server.run(@options) do
+          run API.instance
+        end
+      end
+      block_until_started
+    end
+
+    def url
+      "http://localhost:#{@options[:Port]}"
+    end
+
+    def block_until_started
+      20.times do
+        return true if started?
+      end
+      raise "TinyServer failed to boot :/"
+    end
+
+    def started?
+      open(url)
+      true
+    rescue OpenURI::HTTPError
+      true
+    rescue Errno::ECONNREFUSED => e
+      sleep 0.1
+      false
+    end
+
+    def stop
+      # yes, this is terrible.
+      @server_thread.kill
+      @server_thread.join
+      @server_thread = nil
+    end
+
+  end
+
+  class API
+    include Singleton
+
+    GET     = "GET"
+    PUT     = "PUT"
+    POST    = "POST"
+    DELETE  = "DELETE"
+
+    attr_reader :routes
+
+    def initialize
+      clear
+    end
+
+    def clear
+      @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))
+    end
+
+    def put(path, response_code, data=nil, &block)
+      @routes[PUT] << Route.new(path, Response.new(response_code,data, &block))
+    end
+
+    def post(path, response_code, data=nil, &block)
+      @routes[POST] << Route.new(path, Response.new(response_code,data, &block))
+    end
+
+    def delete(path, response_code, data=nil, &block)
+      @routes[DELETE] << Route.new(path, Response.new(response_code,data, &block))
+    end
+
+    def call(env)
+      if response = response_for_request(env)
+        response.call
+      else
+        debug_info = {:message => "no data matches the request for #{env['REQUEST_URI']}",
+                      :available_routes => @routes, :request => env}
+        # Uncomment me for glorious debugging
+        #pp :not_found => debug_info
+        [404, {'Content-Type' => 'application/json'}, debug_info.to_json]
+      end
+    end
+
+    def response_for_request(env)
+      if route = @routes[env["REQUEST_METHOD"]].find { |route| route.matches_request?(env["REQUEST_URI"]) }
+        route.response
+      end
+    end
+  end
+
+  class Route
+    attr_reader :response
+
+    def initialize(path_spec, response)
+      @path_spec, @response = path_spec, response
+    end
+
+    def matches_request?(uri)
+      @path_spec === uri
+    end
+
+    def to_s
+      "#{@path_spec} => (#{@response})"
+    end
+
+  end
+
+  class Response
+    HEADERS = {'Content-Type' => 'application/json'}
+
+    def initialize(response_code=200,data=nil, &block)
+      @response_code, @data = response_code, data
+      @block = block_given? ? block : nil
+    end
+
+    def call
+      data = @data || @block.call
+      [@response_code, HEADERS, data]
+    end
+
+    def to_s
+      "#{@response_code} => #{(@data|| @block)}"
+    end
+
+  end
+
+end

data/spec/unit/api_client_spec.rb

@@ -0,0 +1,184 @@
+#
+# 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'
+
+require 'chef/api_client'
+require 'tempfile'
+
+describe Chef::ApiClient do
+  before(:each) 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
+  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
+  end
+
+  describe "admin" do
+    it "should let you set the admin bit" do
+      @client.admin(true).should == true
+    end
+
+    it "should return the current admin value" do
+      @client.admin true 
+      @client.admin.should == true 
+    end
+
+    it "should default to false" do
+      @client.admin.should == 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
+  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 "should throw an ArgumentError if you feed it something lame" do
+      lambda { @client.public_key Hash.new }.should raise_error(ArgumentError)
+    end 
+  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 "should throw an ArgumentError if you feed it something lame" do
+      lambda { @client.private_key Hash.new }.should raise_error(ArgumentError)
+    end 
+  end
+
+  describe "create_keys" 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"
+    end
+
+    it "should set the public key" do
+      @client.create_keys
+      @client.public_key.should == "cert"
+    end
+  end
+
+  describe "serialize" do
+    before(:each) do
+      @client.name("black")
+      @client.public_key("crowes")
+      @client.private_key("monkeypants")
+      @serial = @client.to_json
+    end
+
+    it "should serialize to a json hash" do
+      @client.to_json.should match(/^\{.+\}$/)
+    end
+
+    %w{
+      name
+      public_key
+    }.each do |t| 
+      it "should include '#{t}'" do
+        @serial.should =~ /"#{t}":"#{@client.send(t.to_sym)}"/
+      end
+    end
+
+    it "should include 'admin'" do
+      @serial.should =~ /"admin":false/
+    end
+
+    it "should not include the private key" do
+      @serial.should_not =~ /"private_key":/
+    end
+  end
+
+  describe "deserialize" do
+    before(:each) do
+      @client.name("black")
+      @client.public_key("crowes")
+      @client.private_key("monkeypants")
+      @client.admin(true)
+      @deserial = Chef::JSONCompat.from_json(@client.to_json)
+    end
+
+    it "should deserialize to a Chef::ApiClient object" do
+      @deserial.should be_a_kind_of(Chef::ApiClient)
+    end
+
+    %w{
+      name
+      public_key
+      admin
+    }.each do |t| 
+      it "should match '#{t}'" do
+        @deserial.send(t.to_sym).should == @client.send(t.to_sym)
+      end
+    end
+
+    it "should not include the private key" do
+      @deserial.private_key.should == nil
+    end
+
+  end
+end
+
+