chef-zero 15.0.17 → 15.0.21

data/spec/server_spec.rb

@@ -1,96 +1,96 @@
-require "chef_zero/server"
-require "net/http" unless defined?(Net::HTTP)
-require "uri" unless defined?(URI)
-
-describe ChefZero::Server do
-  context "with a server bound to port 8889" do
-    before :each do
-      @server = ChefZero::Server.new(port: 8889)
-      @server.start_background
-    end
-    after :each do
-      @server.stop
-    end
-
-    it "a second server bound to port 8889 throws EADDRINUSE" do
-      expect { ChefZero::Server.new(port: 8889).start }.to raise_error Errno::EADDRINUSE
-    end
-
-    it "a server bound to range 8889-9999 binds to a port > 8889" do
-      server = ChefZero::Server.new(port: 8889.upto(9999))
-      server.start_background
-      expect(server.port).to be > 8889
-      expect(URI(server.url).port).to be > 8889
-    end
-
-    it "a server bound to range 8889-8889 throws an exception" do
-      expect { ChefZero::Server.new(port: 8889.upto(8889)).start_background }.to raise_error Errno::EADDRINUSE
-    end
-
-    it "has a very patient request timeout" do
-      expect(@server.server.config[:RequestTimeout]).to eq 300
-    end
-
-    context "accept headers" do
-      def get_nodes(accepts)
-        uri = URI(@server.url)
-        httpcall = Net::HTTP.new(uri.host, uri.port)
-        httpcall.get("/nodes", "Accept" => accepts)
-      end
-
-      def get_version
-        uri = URI(@server.url)
-        httpcall = Net::HTTP.new(uri.host, uri.port)
-        httpcall.get("/version", "Accept" => "text/plain, application/json")
-      end
-
-      it "accepts requests with no accept header" do
-        request = Net::HTTP::Get.new("/nodes")
-        request.delete("Accept")
-        uri = URI(@server.url)
-        response = Net::HTTP.new(uri.host, uri.port).request(request)
-        expect(response.code).to eq "200"
-      end
-
-      it "accepts requests with accept: application/json" do
-        expect(get_nodes("application/json").code).to eq "200"
-      end
-
-      it "accepts requests with accept: application/*" do
-        expect(get_nodes("application/*").code).to eq "200"
-      end
-
-      it "accepts requests with accept: application/*" do
-        expect(get_nodes("*/*").code).to eq "200"
-      end
-
-      it "denies requests with accept: application/blah" do
-        expect(get_nodes("application/blah").code).to eq "406"
-      end
-
-      it "denies requests with accept: blah/json" do
-        expect(get_nodes("blah/json").code).to eq "406"
-      end
-
-      it "denies requests with accept: blah/*" do
-        expect(get_nodes("blah/*").code).to eq "406"
-      end
-
-      it "denies requests with accept: blah/*" do
-        expect(get_nodes("blah/*").code).to eq "406"
-      end
-
-      it "denies requests with accept: <empty string>" do
-        expect(get_nodes("").code).to eq "406"
-      end
-
-      it "accepts requests with accept: a/b;a=b;c=d, application/json;a=b, application/xml;a=b" do
-        expect(get_nodes("a/b;a=b;c=d, application/json;a=b, application/xml;a=b").code).to eq "200"
-      end
-
-      it "accepts /version" do
-        expect(get_version.body.start_with?("chef-zero")).to be true
-      end
-    end
-  end
-end
+require "chef_zero/server"
+require "net/http" unless defined?(Net::HTTP)
+require "uri" unless defined?(URI)
+
+describe ChefZero::Server do
+  context "with a server bound to port 8889" do
+    before :each do
+      @server = ChefZero::Server.new(port: 8889)
+      @server.start_background
+    end
+    after :each do
+      @server.stop
+    end
+
+    it "a second server bound to port 8889 throws EADDRINUSE" do
+      expect { ChefZero::Server.new(port: 8889).start }.to raise_error Errno::EADDRINUSE
+    end
+
+    it "a server bound to range 8889-9999 binds to a port > 8889" do
+      server = ChefZero::Server.new(port: 8889.upto(9999))
+      server.start_background
+      expect(server.port).to be > 8889
+      expect(URI(server.url).port).to be > 8889
+    end
+
+    it "a server bound to range 8889-8889 throws an exception" do
+      expect { ChefZero::Server.new(port: 8889.upto(8889)).start_background }.to raise_error Errno::EADDRINUSE
+    end
+
+    it "has a very patient request timeout" do
+      expect(@server.server.config[:RequestTimeout]).to eq 300
+    end
+
+    context "accept headers" do
+      def get_nodes(accepts)
+        uri = URI(@server.url)
+        httpcall = Net::HTTP.new(uri.host, uri.port)
+        httpcall.get("/nodes", "Accept" => accepts)
+      end
+
+      def get_version
+        uri = URI(@server.url)
+        httpcall = Net::HTTP.new(uri.host, uri.port)
+        httpcall.get("/version", "Accept" => "text/plain, application/json")
+      end
+
+      it "accepts requests with no accept header" do
+        request = Net::HTTP::Get.new("/nodes")
+        request.delete("Accept")
+        uri = URI(@server.url)
+        response = Net::HTTP.new(uri.host, uri.port).request(request)
+        expect(response.code).to eq "200"
+      end
+
+      it "accepts requests with accept: application/json" do
+        expect(get_nodes("application/json").code).to eq "200"
+      end
+
+      it "accepts requests with accept: application/*" do
+        expect(get_nodes("application/*").code).to eq "200"
+      end
+
+      it "accepts requests with accept: application/*" do
+        expect(get_nodes("*/*").code).to eq "200"
+      end
+
+      it "denies requests with accept: application/blah" do
+        expect(get_nodes("application/blah").code).to eq "406"
+      end
+
+      it "denies requests with accept: blah/json" do
+        expect(get_nodes("blah/json").code).to eq "406"
+      end
+
+      it "denies requests with accept: blah/*" do
+        expect(get_nodes("blah/*").code).to eq "406"
+      end
+
+      it "denies requests with accept: blah/*" do
+        expect(get_nodes("blah/*").code).to eq "406"
+      end
+
+      it "denies requests with accept: <empty string>" do
+        expect(get_nodes("").code).to eq "406"
+      end
+
+      it "accepts requests with accept: a/b;a=b;c=d, application/json;a=b, application/xml;a=b" do
+        expect(get_nodes("a/b;a=b;c=d, application/json;a=b, application/xml;a=b").code).to eq "200"
+      end
+
+      it "accepts /version" do
+        expect(get_version.body.start_with?("chef-zero")).to be true
+      end
+    end
+  end
+end

data/spec/socketless_server_map_spec.rb

@@ -1,74 +1,74 @@
-require "chef_zero/socketless_server_map"
-
-describe "Socketless Mode" do
-
-  let(:server_map) { ChefZero::SocketlessServerMap.instance.tap(&:reset!) }
-
-  let(:server) { instance_double("ChefZero::Server") }
-
-  let(:second_server) { instance_double("ChefZero::Server") }
-
-  it "registers a socketful server" do
-    server_map.register_port(8889, server)
-    expect(server_map).to have_server_on_port(8889)
-  end
-
-  it "retrieves a server by port" do
-    server_map.register_port(8889, server)
-    expect(ChefZero::SocketlessServerMap.server_on_port(8889)).to eq(server)
-  end
-
-  context "when a no-listen server is registered" do
-
-    let!(:port) { server_map.register_no_listen_server(server) }
-
-    it "assigns the server a low port number" do
-      expect(port).to eq(1)
-    end
-
-    context "and another server is registered" do
-
-      let!(:next_port) { server_map.register_no_listen_server(second_server) }
-
-      it "assigns another port when another server is registered" do
-        expect(next_port).to eq(2)
-      end
-
-      it "raises NoSocketlessPortAvailable when too many servers are registered" do
-        expect { 1000.times { server_map.register_no_listen_server(server) } }.to raise_error(ChefZero::NoSocketlessPortAvailable)
-      end
-
-      it "deregisters a server" do
-        expect(server_map).to have_server_on_port(1)
-        server_map.deregister(1)
-        expect(server_map).to_not have_server_on_port(1)
-      end
-
-      describe "routing requests to a server" do
-
-        let(:rack_req) do
-          r = {}
-          r["REQUEST_METHOD"] = "GET"
-          r["SCRIPT_NAME"] = ""
-          r["PATH_INFO"] = "/clients"
-          r["QUERY_STRING"] = ""
-          r["rack.input"] = StringIO.new("")
-          r
-        end
-
-        let(:rack_response) { [200, {}, ["this is the response body"] ] }
-
-        it "routes a request to the registered port" do
-          expect(server).to receive(:handle_socketless_request).with(rack_req).and_return(rack_response)
-          response = server_map.request(1, rack_req)
-          expect(response).to eq(rack_response)
-        end
-
-        it "raises ServerNotFound when a request is sent to an unregistered port" do
-          expect { server_map.request(99, rack_req) }.to raise_error(ChefZero::ServerNotFound)
-        end
-      end
-    end
-  end
-
-end
+require "chef_zero/socketless_server_map"
+
+describe "Socketless Mode" do
+
+  let(:server_map) { ChefZero::SocketlessServerMap.instance.tap(&:reset!) }
+
+  let(:server) { instance_double("ChefZero::Server") }
+
+  let(:second_server) { instance_double("ChefZero::Server") }
+
+  it "registers a socketful server" do
+    server_map.register_port(8889, server)
+    expect(server_map).to have_server_on_port(8889)
+  end
+
+  it "retrieves a server by port" do
+    server_map.register_port(8889, server)
+    expect(ChefZero::SocketlessServerMap.server_on_port(8889)).to eq(server)
+  end
+
+  context "when a no-listen server is registered" do
+
+    let!(:port) { server_map.register_no_listen_server(server) }
+
+    it "assigns the server a low port number" do
+      expect(port).to eq(1)
+    end
+
+    context "and another server is registered" do
+
+      let!(:next_port) { server_map.register_no_listen_server(second_server) }
+
+      it "assigns another port when another server is registered" do
+        expect(next_port).to eq(2)
+      end
+
+      it "raises NoSocketlessPortAvailable when too many servers are registered" do
+        expect { 1000.times { server_map.register_no_listen_server(server) } }.to raise_error(ChefZero::NoSocketlessPortAvailable)
+      end
+
+      it "deregisters a server" do
+        expect(server_map).to have_server_on_port(1)
+        server_map.deregister(1)
+        expect(server_map).to_not have_server_on_port(1)
+      end
+
+      describe "routing requests to a server" do
+
+        let(:rack_req) do
+          r = {}
+          r["REQUEST_METHOD"] = "GET"
+          r["SCRIPT_NAME"] = ""
+          r["PATH_INFO"] = "/clients"
+          r["QUERY_STRING"] = ""
+          r["rack.input"] = StringIO.new("")
+          r
+        end
+
+        let(:rack_response) { [200, {}, ["this is the response body"] ] }
+
+        it "routes a request to the registered port" do
+          expect(server).to receive(:handle_socketless_request).with(rack_req).and_return(rack_response)
+          response = server_map.request(1, rack_req)
+          expect(response).to eq(rack_response)
+        end
+
+        it "raises ServerNotFound when a request is sent to an unregistered port" do
+          expect { server_map.request(99, rack_req) }.to raise_error(ChefZero::ServerNotFound)
+        end
+      end
+    end
+  end
+
+end

data/spec/support/oc_pedant.rb

@@ -1,149 +1,149 @@
-# 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
-#
-#     https://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.
-
-# This annotated Pedant configuration file details the various
-# configuration settings available to you.  It is separate from the
-# actual Pedant::Config class because not all settings have sane
-# defaults, and not all settings are appropriate in all settings.
-
-################################################################################
-# You MUST specify the address of the server the API requests will be
-# sent to.  Only specify protocol, hostname, and port.
-chef_server "http://127.0.0.1:8889"
-
-# If you are doing development testing, you can specify the address of
-# the Solr server.  The presence of this parameter will enable tests
-# to force commits to Solr, greatly decreasing the amout of time
-# needed for testing the search endpoint.  This is only an
-# optimization for development!  If you are testing a "live" Chef
-# Server, or otherwise do not have access to the Solr server from your
-# testing location, you should not specify a value for this parameter.
-# The tests will still run, albeit slower, as they will now need to
-# poll for a period to ensure they are querying committed results.
-# search_server "http://localhost:8983"
-
-# Related to the 'search_server' parameter, this specifies the maximum
-# amout of time (in seconds) that search endpoint requests should be
-# retried before giving up.  If not explicitly set, it will default to
-# 65 seconds; only set it if you know that your Solr commit interval
-# differs significantly from this.
-maximum_search_time 0
-
-# OSC sends erchef a host header with a port, so this option needs
-# # to be enabled for Pedant tests to work correctly
-explicit_port_url true
-
-server_api_version 0
-
-internal_server chef_server
-
-# see dummy_endpoint.rb for details.
-search_server   chef_server
-search_commit_url "/dummy"
-search_url_fmt    "/dummy?fq=+X_CHEF_type_CHEF_X:%{type}&q=%{query}&wt=json"
-
-# We're starting to break tests up into groups based on different
-# criteria.  The proper API tests (the results of which are viewable
-# to OPC customers) should be the only ones run by Pedant embedded in
-# OPC installs.  There are other specs that help us keep track of API
-# cruft that we want to come back and fix later; these shouldn't be
-# viewable to customers, but we should be able to run them in
-# development and CI environments.  If this parameter is missing or
-# explicitly `false` only the customer-friendly tests will be run.
-#
-# This is mainly here for documentation purposes, since the
-# command-line `opscode-pedant` utility ultimately determines this
-# value.
-include_internal false
-
-key = "spec/support/stickywicket.pem"
-
-org(name: "pedant-testorg",
-    create_me: !ENV["CHEF_FS"],
-    validator_key: key)
-
-internal_account_url chef_server
-delete_org true
-
-# Test users.  The five users specified below are required; their
-# names (:user, :non_org_user, etc.) are indicative of their role
-# within the tests.  All users must have a ':name' key.  If they have
-# a ':create_me' key, Pedant will create these users for you.  If you
-# are using pre-existing users, you must supply a ':key_file' key,
-# which should be the fully-qualified path /on the machine Pedant is
-# running on/ to a private key for that user.
-superuser_name "pivotal"
-
-def cheffs_or_else_user(value)
-  ENV["CHEF_FS"] ? "pivotal" : value
-end
-
-keyfile_maybe = ENV["CHEF_FS"] ? { key_file: key } : { key_file: nil }
-
-requestors({
-             clients: {
-               # The the admin user, for the purposes of getting things rolling
-               admin: {
-                 name: "pedant_admin_client",
-                 create_me: true,
-                 create_knife: true,
-                 admin: true,
-               },
-               non_admin: {
-                 name: "pedant_client",
-                 create_me: true,
-                 create_knife: true,
-               },
-               bad: {
-                 name: "bad_client",
-                 create_me: true,
-                 create_knife: true,
-                 bogus: true,
-               },
-             },
-
-             users: {
-               # An administrator in the testing organization
-               admin: {
-                 name: cheffs_or_else_user("pedant_admin_user"),
-                 create_me: !ENV["CHEF_FS"],
-                 associate: !ENV["CHEF_FS"],
-                 create_knife: true,
-               }.merge(keyfile_maybe),
-
-               non_admin: {
-                 name: cheffs_or_else_user("pedant_user"),
-                 create_me: !ENV["CHEF_FS"],
-                 associate: !ENV["CHEF_FS"],
-                 create_knife: true,
-               }.merge(keyfile_maybe),
-
-               # A user that is not a member of the testing organization
-               bad: {
-                 name: cheffs_or_else_user("pedant-nobody"),
-                 create_me: !ENV["CHEF_FS"],
-                 create_knife: true,
-                 associate: false,
-               }.merge(keyfile_maybe),
-             },
-           })
-
-self[:tags] = %i{validation authentication authorization}
-verify_error_messages false
-
-ruby_users_endpoint? false
-ruby_acls_endpoint? false
-ruby_org_assoc? false
-chef_12? true
+# 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
+#
+#     https://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.
+
+# This annotated Pedant configuration file details the various
+# configuration settings available to you.  It is separate from the
+# actual Pedant::Config class because not all settings have sane
+# defaults, and not all settings are appropriate in all settings.
+
+################################################################################
+# You MUST specify the address of the server the API requests will be
+# sent to.  Only specify protocol, hostname, and port.
+chef_server "http://127.0.0.1:8889"
+
+# If you are doing development testing, you can specify the address of
+# the Solr server.  The presence of this parameter will enable tests
+# to force commits to Solr, greatly decreasing the amout of time
+# needed for testing the search endpoint.  This is only an
+# optimization for development!  If you are testing a "live" Chef
+# Server, or otherwise do not have access to the Solr server from your
+# testing location, you should not specify a value for this parameter.
+# The tests will still run, albeit slower, as they will now need to
+# poll for a period to ensure they are querying committed results.
+# search_server "http://localhost:8983"
+
+# Related to the 'search_server' parameter, this specifies the maximum
+# amout of time (in seconds) that search endpoint requests should be
+# retried before giving up.  If not explicitly set, it will default to
+# 65 seconds; only set it if you know that your Solr commit interval
+# differs significantly from this.
+maximum_search_time 0
+
+# OSC sends erchef a host header with a port, so this option needs
+# # to be enabled for Pedant tests to work correctly
+explicit_port_url true
+
+server_api_version 0
+
+internal_server chef_server
+
+# see dummy_endpoint.rb for details.
+search_server   chef_server
+search_commit_url "/dummy"
+search_url_fmt    "/dummy?fq=+X_CHEF_type_CHEF_X:%{type}&q=%{query}&wt=json"
+
+# We're starting to break tests up into groups based on different
+# criteria.  The proper API tests (the results of which are viewable
+# to OPC customers) should be the only ones run by Pedant embedded in
+# OPC installs.  There are other specs that help us keep track of API
+# cruft that we want to come back and fix later; these shouldn't be
+# viewable to customers, but we should be able to run them in
+# development and CI environments.  If this parameter is missing or
+# explicitly `false` only the customer-friendly tests will be run.
+#
+# This is mainly here for documentation purposes, since the
+# command-line `opscode-pedant` utility ultimately determines this
+# value.
+include_internal false
+
+key = "spec/support/stickywicket.pem"
+
+org(name: "pedant-testorg",
+  create_me: !ENV["CHEF_FS"],
+  validator_key: key)
+
+internal_account_url chef_server
+delete_org true
+
+# Test users.  The five users specified below are required; their
+# names (:user, :non_org_user, etc.) are indicative of their role
+# within the tests.  All users must have a ':name' key.  If they have
+# a ':create_me' key, Pedant will create these users for you.  If you
+# are using pre-existing users, you must supply a ':key_file' key,
+# which should be the fully-qualified path /on the machine Pedant is
+# running on/ to a private key for that user.
+superuser_name "pivotal"
+
+def cheffs_or_else_user(value)
+  ENV["CHEF_FS"] ? "pivotal" : value
+end
+
+keyfile_maybe = ENV["CHEF_FS"] ? { key_file: key } : { key_file: nil }
+
+requestors({
+             clients: {
+               # The the admin user, for the purposes of getting things rolling
+               admin: {
+                 name: "pedant_admin_client",
+                 create_me: true,
+                 create_knife: true,
+                 admin: true,
+               },
+               non_admin: {
+                 name: "pedant_client",
+                 create_me: true,
+                 create_knife: true,
+               },
+               bad: {
+                 name: "bad_client",
+                 create_me: true,
+                 create_knife: true,
+                 bogus: true,
+               },
+             },
+
+             users: {
+               # An administrator in the testing organization
+               admin: {
+                 name: cheffs_or_else_user("pedant_admin_user"),
+                 create_me: !ENV["CHEF_FS"],
+                 associate: !ENV["CHEF_FS"],
+                 create_knife: true,
+               }.merge(keyfile_maybe),
+
+               non_admin: {
+                 name: cheffs_or_else_user("pedant_user"),
+                 create_me: !ENV["CHEF_FS"],
+                 associate: !ENV["CHEF_FS"],
+                 create_knife: true,
+               }.merge(keyfile_maybe),
+
+               # A user that is not a member of the testing organization
+               bad: {
+                 name: cheffs_or_else_user("pedant-nobody"),
+                 create_me: !ENV["CHEF_FS"],
+                 create_knife: true,
+                 associate: false,
+               }.merge(keyfile_maybe),
+             },
+           })
+
+self[:tags] = %i{validation authentication authorization}
+verify_error_messages false
+
+ruby_users_endpoint? false
+ruby_acls_endpoint? false
+ruby_org_assoc? false
+chef_12? true