microwave 1.0.4 → 11.400.2

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

@@ -0,0 +1,110 @@
+#
+# 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 'chef/chef_fs/file_system'
+require 'chef/chef_fs/file_system/base_fs_dir'
+require 'chef/chef_fs/file_system/base_fs_object'
+
+module FileSystemSupport
+  class MemoryFile < Chef::ChefFS::FileSystem::BaseFSObject
+    def initialize(name, parent, value)
+      super(name, parent)
+      @value = value
+    end
+    def read
+      return @value
+    end
+  end
+
+  class MemoryDir < Chef::ChefFS::FileSystem::BaseFSDir
+    def initialize(name, parent)
+      super(name, parent)
+      @children = []
+    end
+    attr_reader :children
+    def child(name)
+      @children.select { |child| child.name == name }.first || Chef::ChefFS::FileSystem::NonexistentFSObject.new(name, self)
+    end
+    def add_child(child)
+      @children.push(child)
+    end
+    def can_have_child?(name, is_dir)
+      root.cannot_be_in_regex ? (name !~ root.cannot_be_in_regex) : true
+    end
+  end
+
+  class MemoryRoot < MemoryDir
+    def initialize(pretty_name, cannot_be_in_regex = nil)
+      super('', nil)
+      @pretty_name = pretty_name
+      @cannot_be_in_regex = cannot_be_in_regex
+    end
+
+    attr_reader :cannot_be_in_regex
+
+    def path_for_printing
+      @pretty_name
+    end
+  end
+
+  def memory_fs(pretty_name, value, cannot_be_in_regex = nil)
+    if !value.is_a?(Hash)
+      raise "memory_fs() must take a Hash"
+    end
+    dir = MemoryRoot.new(pretty_name, cannot_be_in_regex)
+    value.each do |key, child|
+      dir.add_child(memory_fs_value(child, key.to_s, dir))
+    end
+    dir
+  end
+
+  def memory_fs_value(value, name = '', parent = nil)
+    if value.is_a?(Hash)
+      dir = MemoryDir.new(name, parent)
+      value.each do |key, child|
+        dir.add_child(memory_fs_value(child, key.to_s, dir))
+      end
+      dir
+    else
+      MemoryFile.new(name, parent, value || "#{name}\n")
+    end
+  end
+
+  def pattern(p)
+    Chef::ChefFS::FilePattern.new(p)
+  end
+
+  def return_paths(*expected)
+    ReturnPaths.new(expected)
+  end
+
+  def no_blocking_calls_allowed
+    [ MemoryFile, MemoryDir ].each do |c|
+      [ :children, :exists?, :read ].each do |m|
+        c.any_instance.stub(m).and_raise("#{m.to_s} should not be called")
+      end
+    end
+  end
+
+  def list_should_yield_paths(fs, pattern_str, *expected_paths)
+    result_paths = []
+    Chef::ChefFS::FileSystem.list(fs, pattern(pattern_str)) { |result| result_paths << result.path }
+    result_paths.should =~ expected_paths
+  end
+end
+

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

@@ -0,0 +1,162 @@
+#
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010, 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.
+#
+
+
+shared_examples_for "a platform introspector" do
+  before(:each) do
+    @platform_hash = {}
+    %w{openbsd freebsd}.each do |x|
+      @platform_hash[x] = {
+        "default" => x,
+        "1.2.3" => "#{x}-1.2.3"
+      }
+    end
+    @platform_hash["debian"] = {["5", "6"] => "debian-5/6", "default" => "debian"}
+    @platform_hash["default"] = "default"
+
+    @platform_family_hash = {
+      "debian" => "debian value",
+      [:rhel, :fedora] => "redhatty value",
+      "suse" => "suse value",
+      :default => "default value"
+    }
+  end
+
+  it "returns a default value when there is no known platform" do
+    node = Hash.new
+    platform_introspector.value_for_platform(@platform_hash).should == "default"
+  end
+
+  it "returns a default value when there is no known platform family" do
+    platform_introspector.value_for_platform_family(@platform_family_hash).should == "default value"
+  end
+
+  it "returns a default value when the current platform doesn't match" do
+    node.automatic_attrs[:platform] = "not-a-known-platform"
+    platform_introspector.value_for_platform(@platform_hash).should == "default"
+  end
+
+  it "returns a default value when current platform_family doesn't match" do
+    node.automatic_attrs[:platform_family] = "ultra-derived-linux"
+    platform_introspector.value_for_platform_family(@platform_family_hash).should == "default value"
+  end
+
+  it "returns a value based on the current platform" do
+    node.automatic_attrs[:platform] = "openbsd"
+    platform_introspector.value_for_platform(@platform_hash).should == "openbsd"
+  end
+
+  it "returns a value based on the current platform family" do
+    node.automatic_attrs[:platform_family] = "debian"
+    platform_introspector.value_for_platform_family(@platform_family_hash).should == "debian value"
+  end
+
+  it "returns a version-specific value based on the current platform" do
+    node.automatic_attrs[:platform] = "openbsd"
+    node.automatic_attrs[:platform_version] = "1.2.3"
+    platform_introspector.value_for_platform(@platform_hash).should == "openbsd-1.2.3"
+  end
+
+  it "returns a value based on the current platform if version not found" do
+    node.automatic_attrs[:platform] = "openbsd"
+    node.automatic_attrs[:platform_version] = "0.0.0"
+    platform_introspector.value_for_platform(@platform_hash).should == "openbsd"
+  end
+
+  describe "when platform versions is an array" do
+    it "returns a version-specific value based on the current platform" do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = "6"
+      platform_introspector.value_for_platform(@platform_hash).should == "debian-5/6"
+    end
+
+    it "returns a value based on the current platform if version not found" do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = "0.0.0"
+      platform_introspector.value_for_platform(@platform_hash).should == "debian"
+    end
+  end
+
+  describe "when checking platform?" do
+
+    it "returns true if the node is a provided platform and platforms are provided as symbols" do
+      node.automatic_attrs[:platform] = 'ubuntu'
+      platform_introspector.platform?([:redhat, :ubuntu]).should == true
+    end
+
+    it "returns true if the node is a provided platform and platforms are provided as strings" do
+      node.automatic_attrs[:platform] = 'ubuntu'
+      platform_introspector.platform?(["redhat", "ubuntu"]).should == true
+    end
+
+    it "returns false if the node is not of the provided platforms" do
+      node.automatic_attrs[:platform] = 'ubuntu'
+      platform_introspector.platform?(:splatlinux).should == false
+    end
+  end
+
+  describe "when checking platform_family?" do
+
+    it "returns true if the node is in a provided platform family and families are provided as symbols" do
+      node.automatic_attrs[:platform_family] = 'debian'
+      platform_introspector.platform_family?([:rhel, :debian]).should == true
+    end
+
+    it "returns true if the node is a provided platform and platforms are provided as strings" do
+      node.automatic_attrs[:platform_family] = 'rhel'
+      platform_introspector.platform_family?(["rhel", "debian"]).should == true
+    end
+
+    it "returns false if the node is not of the provided platforms" do
+      node.automatic_attrs[:platform_family] = 'suse'
+      platform_introspector.platform_family?(:splatlinux).should == false
+    end
+
+    it "returns false if the node is not of the provided platforms and platform_family is not set" do
+      platform_introspector.platform_family?(:splatlinux).should == false
+    end
+
+  end
+  # NOTE: this is a regression test for bug CHEF-1514
+  describe "when the value is an array" do
+    before do
+      @platform_hash = {
+        "debian" => { "4.0" => [ :restart, :reload ], "default" => [ :restart, :reload, :status ] },
+        "ubuntu" => { "default" => [ :restart, :reload, :status ] },
+        "centos" => { "default" => [ :restart, :reload, :status ] },
+        "redhat" => { "default" => [ :restart, :reload, :status ] },
+        "fedora" => { "default" => [ :restart, :reload, :status ] },
+        "default" => { "default" => [:restart, :reload ] }}
+    end
+
+    it "returns the correct default for a given platform" do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = '9000'
+      platform_introspector.value_for_platform(@platform_hash).should == [ :restart, :reload, :status ]
+    end
+
+    it "returns the correct platform+version specific value " do
+      node.automatic_attrs[:platform] = "debian"
+      node.automatic_attrs[:platform_version] = '4.0'
+      platform_introspector.value_for_platform(@platform_hash).should == [:restart, :reload]
+    end
+  end
+
+end
+

data/spec/tiny_server.rb

@@ -17,11 +17,13 @@
 #
 
 require 'rubygems'
+require 'webrick'
 require 'rack'
-require 'thin'
+#require 'thin'
 require 'singleton'
 require 'chef/json_compat'
 require 'open-uri'
+require 'chef/config'
 
 module TinyServer
 
@@ -29,30 +31,42 @@ module TinyServer
 
     attr_writer :app
 
-    def self.run(options=nil, &block)
+    def self.setup(options=nil, &block)
       tiny_app = new(options)
       app_code = Rack::Builder.new(&block).to_app
       tiny_app.app = app_code
-      tiny_app.start
+      tiny_app
+    end
+
+    def shutdown
+      server.shutdown
     end
   end
 
   class Manager
 
-    DEFAULT_OPTIONS = {:server => 'thin', :Port => 9000, :Host => 'localhost', :environment => :none}
+    # 5 == debug, 3 == warning
+    LOGGER = WEBrick::Log.new(STDOUT, 3)
+    DEFAULT_OPTIONS = {
+      :server => 'webrick',
+      :Port => 9000,
+      :Host => 'localhost',
+      :environment => :none,
+      :Logger => LOGGER,
+      :AccessLog => [] # Remove this option to enable the access log when debugging.
+    }
 
     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
+        @server = Server.setup(@options) do
           run API.instance
         end
+        @server.start
       end
       block_until_started
     end
@@ -63,8 +77,11 @@ module TinyServer
 
     def block_until_started
       200.times do
-        return true if started?
+        if started? && !@server.nil?
+          return true
+        end
       end
+      raise "ivar weirdness" if started? && @server.nil?
       raise "TinyServer failed to boot :/"
     end
 
@@ -84,6 +101,7 @@ module TinyServer
 
     def stop
       # yes, this is terrible.
+      @server.shutdown
       @server_thread.kill
       @server_thread.join
       @server_thread = nil
@@ -132,7 +150,7 @@ module TinyServer
         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
+        # pp :not_found => debug_info
         [404, {'Content-Type' => 'application/json'}, debug_info.to_json]
       end
     end
@@ -152,6 +170,7 @@ module TinyServer
     end
 
     def matches_request?(uri)
+      uri = URI.parse(uri).request_uri
       @path_spec === uri
     end
 
@@ -171,7 +190,7 @@ module TinyServer
 
     def call
       data = @data || @block.call
-      [@response_code, HEADERS, data]
+      [@response_code, 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
+
+