chef 18.8.11 → 18.8.54

data/spec/unit/org_group_spec.rb

@@ -1,45 +0,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/org"
-
-describe Chef::Org do
-  let(:org) { Chef::Org.new("myorg") }
-
-  describe "API Interactions" do
-    before(:each) do
-      Chef::Config[:chef_server_root] = "http://www.example.com"
-      @rest = double("rest")
-      allow(Chef::ServerAPI).to receive(:new).and_return(@rest)
-    end
-
-    describe "group" do
-      it "should load group data when it's not loaded." do
-        expect(@rest).to receive(:get_rest).with("organizations/myorg/groups/admins").and_return({})
-        org.group("admins")
-      end
-
-      it "should not load group data a second time when it's already loaded." do
-        expect(@rest).to receive(:get_rest)
-          .with("organizations/myorg/groups/admins")
-          .and_return({ anything: "goes" })
-          .exactly(:once)
-        admin1 = org.group("admins")
-        admin2 = org.group("admins")
-        expect(admin1).to eq admin2
-      end
-    end
-  end
-end

data/spec/unit/org_spec.rb

@@ -1,196 +0,0 @@
-#
-# Author:: Steven Danna (steve@chef.io)
-# Copyright:: Copyright (c) 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/org"
-require "tempfile"
-
-describe Chef::Org do
-  let(:org) { Chef::Org.new("an_org") }
-
-  describe "initialize" do
-    it "is a Chef::Org" do
-      expect(org).to be_a_kind_of(Chef::Org)
-    end
-  end
-
-  describe "name" do
-    it "lets you set the name to a string" do
-      org.name "sg1"
-      expect(org.name).to eq("sg1")
-    end
-
-    # It is not feasible to check all invalid characters.  Here are a few
-    # that we probably care about.
-    it "raises on invalid characters" do
-      # capital letters
-      expect { org.name "Bar" }.to raise_error(ArgumentError)
-      # slashes
-      expect { org.name "foo/bar" }.to raise_error(ArgumentError)
-      # ?
-      expect { org.name "foo?" }.to raise_error(ArgumentError)
-      # &
-      expect { org.name "foo&" }.to raise_error(ArgumentError)
-      # spaces
-      expect { org.name "foo " }.to raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError if you feed it anything but a string" do
-      expect { org.name({}) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "full_name" do
-    it "lets you set the full name" do
-      org.full_name "foo"
-      expect(org.full_name).to eq("foo")
-    end
-
-    it "raises an ArgumentError if you feed it anything but a string" do
-      expect { org.name({}) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "private_key" do
-    it "returns the private key" do
-      org.private_key("super private")
-      expect(org.private_key).to eq("super private")
-    end
-
-    it "raises an ArgumentError if you feed it something lame" do
-      expect { org.private_key({}) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "when serializing to JSON" do
-    let(:json) do
-      org.name("black")
-      org.full_name("black crowes")
-      org.to_json
-    end
-
-    it "serializes as a JSON object" do
-      expect(json).to match(/^\{.+\}$/)
-    end
-
-    it "includes the name value" do
-      expect(json).to include(%q{"name":"black"})
-    end
-
-    it "includes the full name value" do
-      expect(json).to include(%q{"full_name":"black crowes"})
-    end
-
-    it "includes the private key when present" do
-      org.private_key("monkeypants")
-      expect(org.to_json).to include(%q{"private_key":"monkeypants"})
-    end
-
-    it "does not include the private key if not present" do
-      expect(json).to_not include("private_key")
-    end
-  end
-
-  describe "when deserializing from JSON" do
-    let(:org) do
-      o = { "name" => "turtle",
-            "full_name" => "turtle_club",
-            "private_key" => "pandas" }
-      Chef::Org.from_json(o.to_json)
-    end
-
-    it "deserializes to a Chef::Org object" do
-      expect(org).to be_a_kind_of(Chef::Org)
-    end
-
-    it "preserves the name" do
-      expect(org.name).to eq("turtle")
-    end
-
-    it "preserves the full_name" do
-      expect(org.full_name).to eq("turtle_club")
-    end
-
-    it "includes the private key if present" do
-      expect(org.private_key).to eq("pandas")
-    end
-  end
-
-  describe "API Interactions" do
-    let(:rest) do
-      Chef::Config[:chef_server_root] = "http://www.example.com"
-      r = double("rest")
-      allow(Chef::ServerAPI).to receive(:new).and_return(r)
-      r
-    end
-
-    let(:org) do
-      o = Chef::Org.new("foobar")
-      o.full_name "foo bar bat"
-      o
-    end
-
-    describe "list" do
-      let(:response) { { "foobar" => "http://www.example.com/organizations/foobar" } }
-      let(:inflated_response) { { "foobar" => org } }
-
-      it "lists all orgs" do
-        expect(rest).to receive(:get).with("organizations").and_return(response)
-        expect(Chef::Org.list).to eq(response)
-      end
-
-      it "inflate all orgs" do
-        allow(Chef::Org).to receive(:load).with("foobar").and_return(org)
-        expect(rest).to receive(:get).with("organizations").and_return(response)
-        expect(Chef::Org.list(true)).to eq(inflated_response)
-      end
-    end
-
-    describe "create" do
-      it "creates a new org via the API" do
-        expect(rest).to receive(:post).with("organizations", { name: "foobar", full_name: "foo bar bat" }).and_return({})
-        org.create
-      end
-    end
-
-    describe "read" do
-      it "loads a named org from the API" do
-        expect(rest).to receive(:get).with("organizations/foobar").and_return({ "name" => "foobar", "full_name" => "foo bar bat", "private_key" => "private" })
-        org = Chef::Org.load("foobar")
-        expect(org.name).to eq("foobar")
-        expect(org.full_name).to eq("foo bar bat")
-        expect(org.private_key).to eq("private")
-      end
-    end
-
-    describe "update" do
-      it "updates an existing org on via the API" do
-        expect(rest).to receive(:put).with("organizations/foobar", { name: "foobar", full_name: "foo bar bat" }).and_return({})
-        org.update
-      end
-    end
-
-    describe "destroy" do
-      it "deletes the specified org via the API" do
-        expect(rest).to receive(:delete).with("organizations/foobar")
-        org.destroy
-      end
-    end
-  end
-end

data/spec/unit/platform/query_helpers_spec.rb

@@ -1,48 +0,0 @@
-#
-# Author:: Bryan McLellan <btm@loftninjas.org>
-# Copyright:: Copyright (c) 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::Platform#supports_dsc_invoke_resource?", :windows_only do
-  it "returns false if powershell is not present" do
-    node = Chef::Node.new
-    expect(Chef::Platform.supports_dsc_invoke_resource?(node)).to be_falsey
-  end
-
-  ["1.0", "2.0", "3.0", "4.0", "5.0.10017.9"].each do |version|
-    it "returns false for PowerShell #{version}" do
-      node = Chef::Node.new
-      node.automatic[:languages][:powershell][:version] = version
-      expect(Chef::Platform.supports_dsc_invoke_resource?(node)).to be_falsey
-    end
-  end
-
-  it "returns true for Powershell 5.0.10018.0" do
-    node = Chef::Node.new
-    node.automatic[:languages][:powershell][:version] = "5.0.10018.0"
-    expect(Chef::Platform.supports_dsc_invoke_resource?(node)).to be_truthy
-  end
-end
-
-describe "Chef::Platform#dsc_refresh_mode_disabled?", :windows_only do
-  let(:node) { instance_double("Chef::Node") }
-
-  it "returns true when RefreshMode is Disabled" do
-    expect(Chef::Platform.dsc_refresh_mode_disabled?(node)).to be false
-  end
-end

data/spec/unit/policy_builder/dynamic_spec.rb

@@ -1,256 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) 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/policy_builder"
-
-describe Chef::PolicyBuilder::Dynamic do
-
-  let(:node_name) { "joe_node" }
-  let(:ohai_data) { { "platform" => "ubuntu", "platform_version" => "13.04", "fqdn" => "joenode.example.com" } }
-  let(:json_attribs) { { "custom_attr" => "custom_attr_value" } }
-  let(:override_runlist) { nil }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-
-  let(:err_namespace) { Chef::PolicyBuilder::Policyfile }
-
-  let(:base_node) do
-    node = Chef::Node.new
-    node.name(node_name)
-    node
-  end
-
-  let(:node) { base_node }
-
-  subject(:policy_builder) { Chef::PolicyBuilder::Dynamic.new(node_name, ohai_data, json_attribs, override_runlist, events) }
-
-  describe "loading policy data" do
-
-    describe "delegating PolicyBuilder API to the correct implementation" do
-
-      let(:implementation) { instance_double("Chef::PolicyBuilder::Policyfile") }
-
-      before do
-        allow(policy_builder).to receive(:implementation).and_return(implementation)
-      end
-
-      # Dynamic should load_node, figure out the correct backend, then forward
-      # messages to it after. That behavior is tested below.
-      it "responds to #load_node" do
-        expect(policy_builder).to respond_to(:load_node)
-      end
-
-      it "forwards #run_context" do
-        expect(implementation).to receive(:run_context)
-        policy_builder.run_context
-      end
-
-      it "forwards #run_list_expansion" do
-        expect(implementation).to receive(:run_list_expansion)
-        policy_builder.run_list_expansion
-      end
-
-      it "forwards #build_node to the implementation object" do
-        expect(implementation).to receive(:build_node)
-        policy_builder.build_node
-      end
-
-      it "forwards #setup_run_context to the implementation object" do
-        expect(implementation).to receive(:setup_run_context)
-        policy_builder.setup_run_context
-
-        arg = Object.new
-
-        expect(implementation).to receive(:setup_run_context).with(arg)
-        policy_builder.setup_run_context(arg)
-      end
-
-      it "forwards #expand_run_list to the implementation object" do
-        expect(implementation).to receive(:expand_run_list)
-        policy_builder.expand_run_list
-      end
-
-      it "forwards #sync_cookbooks to the implementation object" do
-        expect(implementation).to receive(:sync_cookbooks)
-        policy_builder.sync_cookbooks
-      end
-
-      it "forwards #temporary_policy? to the implementation object" do
-        expect(implementation).to receive(:temporary_policy?)
-        policy_builder.temporary_policy?
-      end
-
-    end
-
-    describe "selecting a backend implementation" do
-
-      let(:implementation) do
-        policy_builder.select_implementation(node)
-        policy_builder.implementation
-      end
-
-      context "when no policyfile attributes are present on the node" do
-
-        context "and json_attribs are not given" do
-
-          let(:json_attribs) { {} }
-
-          it "uses the ExpandNodeObject implementation" do
-            expect(implementation).to be_a(Chef::PolicyBuilder::ExpandNodeObject)
-          end
-
-        end
-
-        context "and no policyfile attributes are present in json_attribs" do
-
-          let(:json_attribs) { { "foo" => "bar" } }
-
-          it "uses the ExpandNodeObject implementation" do
-            expect(implementation).to be_a(Chef::PolicyBuilder::ExpandNodeObject)
-          end
-
-        end
-
-        context "and policy_name and policy_group are set on Chef::Config" do
-
-          before do
-            Chef::Config[:policy_name] = "example-policy"
-            Chef::Config[:policy_group] = "testing"
-          end
-
-          it "uses the Policyfile implementation" do
-            expect(implementation).to be_a(Chef::PolicyBuilder::Policyfile)
-          end
-
-        end
-
-        context "and deployment_group and policy_document_native_api are set on Chef::Config" do
-
-          before do
-            Chef::Config[:deployment_group] = "example-policy-staging"
-            Chef::Config[:policy_document_native_api] = false
-          end
-
-          it "uses the Policyfile implementation" do
-            expect(implementation).to be_a(Chef::PolicyBuilder::Policyfile)
-          end
-
-        end
-
-        context "and policyfile attributes are present in json_attribs" do
-
-          let(:json_attribs) { { "policy_name" => "example-policy", "policy_group" => "testing" } }
-
-          it "uses the Policyfile implementation" do
-            expect(implementation).to be_a(Chef::PolicyBuilder::Policyfile)
-          end
-
-        end
-
-      end
-
-      context "when policyfile attributes are present on the node" do
-
-        let(:node) do
-          base_node.policy_name = "example-policy"
-          base_node.policy_group = "staging"
-          base_node
-        end
-
-        it "uses the Policyfile implementation" do
-          expect(implementation).to be_a(Chef::PolicyBuilder::Policyfile)
-        end
-
-      end
-
-    end
-
-    describe "loading a node" do
-
-      let(:implementation) { instance_double("Chef::PolicyBuilder::Policyfile") }
-
-      before do
-        allow(policy_builder).to receive(:implementation).and_return(implementation)
-      end
-
-      context "when not running chef solo" do
-
-        context "when successful" do
-
-          before do
-            expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
-            expect(policy_builder).to receive(:select_implementation).with(node)
-            expect(implementation).to receive(:finish_load_node).with(node)
-          end
-
-          it "selects the backend implementation and continues node loading" do
-            policy_builder.load_node
-          end
-
-        end
-
-        context "when an error occurs finding the node" do
-
-          before do
-            expect(Chef::Node).to receive(:find_or_create).with(node_name).and_raise("oops")
-          end
-
-          it "sends a node_load_failed event and re-raises" do
-            expect(events).to receive(:node_load_failed)
-            expect { policy_builder.load_node }.to raise_error("oops")
-          end
-
-        end
-
-        context "when an error occurs in the implementation's finish_load_node call" do
-
-          before do
-            expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
-            expect(policy_builder).to receive(:select_implementation).with(node)
-            expect(implementation).to receive(:finish_load_node).and_raise("oops")
-          end
-
-          it "sends a node_load_failed event and re-raises" do
-            expect(events).to receive(:node_load_failed)
-            expect { policy_builder.load_node }.to raise_error("oops")
-          end
-
-        end
-
-      end
-
-      context "when running chef solo" do
-
-        before do
-          Chef::Config[:solo_legacy_mode] = true
-          expect(Chef::Node).to receive(:build).with(node_name).and_return(node)
-          expect(policy_builder).to receive(:select_implementation).with(node)
-          expect(implementation).to receive(:finish_load_node).with(node)
-        end
-
-        it "selects the backend implementation and continues node loading" do
-          policy_builder.load_node
-        end
-
-      end
-
-    end
-
-  end
-
-end