chef-cli 1.0.3

data/spec/unit/policyfile/git_lock_fetcher_spec.rb

@@ -0,0 +1,155 @@
+#
+# Copyright:: Copyright (c) 2018 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-cli/policyfile/git_lock_fetcher"
+
+describe ChefCLI::Policyfile::GitLockFetcher do
+
+  let(:revision_id) { "6fe753184c8946052d3231bb4212116df28d89a3a5f7ae52832ad408419dd5eb" }
+  let(:identifier) { "fab501cfaf747901bd82c1bc706beae7dc3a350c" }
+  let(:git_revision) { "8404a9e0b5c27c55d529e61222e14f950b6e4171" }
+  let(:rel) { "cookbooks/nested_cookbook" }
+  let(:cookbook_name) { "git-cookbook" }
+  let(:nested_cookbook_name) { "cookbooks/nested-cookbook" }
+  let(:repo) { "https://github.com/monkeynews/bananas" }
+
+  let(:minimal_lockfile_json) do
+    <<~E
+      {
+        "revision_id": "#{revision_id}",
+        "name": "install-example",
+        "run_list": [
+          "recipe[#{cookbook_name}::default]"
+        ],
+        "cookbook_locks": {
+          "#{cookbook_name}": {
+            "version": "2.3.4",
+            "identifier": "#{identifier}",
+            "dotted_decimal_identifier": "70567763561641081.489844270461035.258281553147148",
+            "cache_key": "#{cookbook_name}-#{git_revision}",
+            "source_options": {
+              "git": "#{repo}",
+              "revision": "#{git_revision}"
+            }
+          }
+        },
+        "default_attributes": {},
+        "override_attributes": {},
+        "solution_dependencies": {
+          "Policyfile": [
+            [
+              "#{cookbook_name}",
+              ">= 0.0.0"
+            ]
+          ],
+          "dependencies": {
+            "#{cookbook_name} (2.3.4)": [
+
+            ]
+          }
+        }
+      }
+    E
+  end
+
+  def minimal_lockfile
+    FFI_Yajl::Parser.parse(minimal_lockfile_json)
+  end
+
+  let(:policy_name) { "git_fetcher" }
+  let(:policy_group) { "somegroup" }
+  let(:storage_config) { ChefCLI::Policyfile::StorageConfig.new.use_policyfile("#{tempdir}/Policyfile.rb") }
+
+  let(:minimal_lockfile_modified) do
+    minimal_lockfile.tap do |lockfile|
+      lockfile["cookbook_locks"][cookbook_name]["source_options"] = {
+        "git" => repo,
+        "revision" => git_revision,
+      }
+    end
+  end
+
+  let(:minimal_lockfile_with_scm_info) do
+    minimal_lockfile_modified.tap do |lockfile|
+      lockfile["cookbook_locks"][cookbook_name]["scm_info"] = {
+        "scm" => "git",
+        "remote" => repo,
+        "revision" => git_revision,
+        "working_tree_clean" => true,
+        "published" => true,
+        "synchronized_remote_branches" => [
+          "origin/master",
+        ],
+      }
+    end
+  end
+
+  let(:source_options) do
+    {
+      git: repo,
+      revision: git_revision,
+    }
+  end
+
+  let(:shellout) { instance_double("Mixlib::ShellOut", run_command: "git") }
+
+  describe "#lock_data" do
+    subject(:lock_data) { described_class.new(policy_name, source_options, storage_config).lock_data }
+
+    it "sets the source_options for dependencies" do
+      expect(Mixlib::ShellOut).to receive(:new).and_return(shellout).at_least(:twice)
+      allow(shellout).to receive(:error?).and_return(false)
+      allow(shellout).to receive(:stdout).and_return(minimal_lockfile_json)
+      allow(Dir).to receive(:chdir).and_return(0)
+
+      expect(lock_data).to include(minimal_lockfile_modified)
+    end
+
+    context "when using a relative path for the policyfile" do
+      let(:source_options_rel) do
+        source_options.collect { |k, v| [k.to_s, v] }.to_h.merge({ "rel" => rel })
+      end
+
+      subject(:relative_path_fetcher) { described_class.new(policy_name, source_options_rel, storage_config) }
+
+      it "omits the relative path of the policyfile from the source_options" do
+        subject { described_class.new(policy_name, source_options_rel, storage_config) }
+
+        expect(Mixlib::ShellOut).to receive(:new).and_return(shellout)
+        allow(shellout).to receive(:error?).and_return(false)
+        allow(shellout).to receive(:stdout).and_return(minimal_lockfile_json)
+        allow(Dir).to receive(:chdir).and_return(0)
+        allow_any_instance_of(described_class).to receive(:cache_path).and_return(
+          Pathname.new(relative_path_fetcher.storage_config.relative_paths_root)
+        )
+
+        expect(
+          relative_path_fetcher.lock_data["cookbook_locks"][cookbook_name]["source_options"]
+        ).to match(
+               {
+                 "git" => repo,
+                 "revision" => git_revision,
+               }
+             )
+        expect(
+          relative_path_fetcher.lock_data["cookbook_locks"][cookbook_name]["source_options"]
+        ).not_to match(source_options_rel)
+      end # it "omits the relative path of the policyfile from the source_options"
+    end # context "when using a relative path for the policyfile"
+  end # describe "#lock_data"
+end # describe ChefCLI::Policyfile::GitLockFetcher

data/spec/unit/policyfile/included_policies_cookbook_source_spec.rb

@@ -0,0 +1,242 @@
+#
+# Copyright:: Copyright (c) 2017 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-cli/policyfile/included_policies_cookbook_source"
+require "chef-cli/policyfile/policyfile_location_specification"
+
+describe ChefCLI::Policyfile::IncludedPoliciesCookbookSource do
+
+  let(:external_cookbook_universe) do
+    {
+      "cookbookA" => {
+        "1.0.0" => [ ],
+        "2.0.0" => [ ["cookbookB", "= 1.0.0" ] ],
+      },
+      "cookbookB" => {
+        "1.0.0" => [ ],
+      },
+      "cookbookC" => {
+        "1.0.0" => [ ],
+        "2.0.0" => [ ],
+      },
+    }
+  end
+
+  let(:policy1_cookbooks) do
+    [
+      {
+        name: "cookbookA",
+        version: "2.0.0",
+      },
+      # cookbookB because cookbookA depends on it
+      {
+        name: "cookbookB",
+        version: "1.0.0",
+      },
+    ]
+  end
+
+  let(:randomize_sources) { false }
+  let(:add_random_cookbook) { false }
+
+  def build_lockdata(cookbooks)
+    nonce = if randomize_sources
+              Random.rand
+            else
+              nil
+            end
+
+    cookbook_locks = cookbooks.inject({}) do |acc, cookbook_info|
+      acc[cookbook_info[:name]] = {
+        "version" => cookbook_info[:version],
+        "identifier" => "identifier",
+        "dotted_decimal_identifier" => "dotted_decimal_identifier",
+        "cache_key" => "#{cookbook_info[:name]}-#{cookbook_info[:version]}",
+        "origin" => "uri",
+        "source_options" => { "version" => cookbook_info[:version] }.tap do |so|
+          so["nonce"] = nonce if !nonce.nil?
+        end,
+      }
+      acc
+    end
+
+    solution_dependencies_lock = cookbooks.map do |cookbook_info|
+      [cookbook_info[:name], cookbook_info[:version]]
+    end
+
+    solution_dependencies_cookbooks = cookbooks.inject({}) do |acc, cookbook_info|
+      acc["#{cookbook_info[:name]} (#{cookbook_info[:version]})"] = external_cookbook_universe[cookbook_info[:name]][cookbook_info[:version]]
+      acc
+    end
+
+    {
+      "name" => "included_policyfile",
+      "revision_id" => "myrevisionid",
+      "run_list" => ["recipe[myrunlist::default]"],
+      "cookbook_locks" => cookbook_locks,
+      "default_attributes" => {},
+      "override_attributes" => {},
+      "solution_dependencies" => {
+        "Policyfile" => solution_dependencies_lock,
+        ## We dont use dependencies, no need to fill it out
+        "dependencies" => solution_dependencies_cookbooks,
+      },
+    }
+  end
+
+  let(:policy1_lockdata) do
+    build_lockdata(policy1_cookbooks)
+  end
+
+  let(:policy2_lockdata) do
+    build_lockdata(policy2_cookbooks)
+  end
+
+  let(:policy1_fetcher) do
+    instance_double("ChefCLI::Policyfile::LocalLockFetcher").tap do |double|
+      allow(double).to receive(:lock_data).and_return(policy1_lockdata)
+      allow(double).to receive(:valid?).and_return(true)
+      allow(double).to receive(:errors).and_return([])
+    end
+  end
+
+  let(:policy2_fetcher) do
+    instance_double("ChefCLI::Policyfile::LocalLockFetcher").tap do |double|
+      allow(double).to receive(:lock_data).and_return(policy2_lockdata)
+      allow(double).to receive(:valid?).and_return(true)
+      allow(double).to receive(:errors).and_return([])
+    end
+  end
+
+  let(:policy1_location_spec) do
+    ChefCLI::Policyfile::PolicyfileLocationSpecification.new("policy1", { path: "somelocation" }, nil).tap do |spec|
+      allow(spec).to receive(:valid?).and_return(true)
+      allow(spec).to receive(:fetcher).and_return(policy1_fetcher)
+    end
+  end
+
+  let(:policy2_location_spec) do
+    ChefCLI::Policyfile::PolicyfileLocationSpecification.new("policy2", { path: "somelocation" }, nil).tap do |spec|
+      allow(spec).to receive(:valid?).and_return(true)
+      allow(spec).to receive(:fetcher).and_return(policy2_fetcher)
+    end
+  end
+
+  let(:policyfiles) { [] }
+
+  let(:cookbook_source) { ChefCLI::Policyfile::IncludedPoliciesCookbookSource.new(policyfiles) }
+
+  context "when no policies are included" do
+    it "returns false for preferred_source_for" do
+      expect(cookbook_source.preferred_source_for?("foo")).to eq(false)
+    end
+
+    it "has an empty universe" do
+      expect(cookbook_source.universe_graph).to eq({})
+    end
+  end
+
+  context "when a single policy is to be included" do
+    let(:policyfiles) { [policy1_location_spec] }
+
+    it "does not have a preferred source for unlocked cookbooks" do
+      expect(cookbook_source.preferred_source_for?("cookbookC")).to eq(false)
+    end
+
+    it "has a preferred source for the included cookbooks" do
+      expect(cookbook_source.preferred_source_for?("cookbookA")).to eq(true)
+      expect(cookbook_source.preferred_source_for?("cookbookB")).to eq(true)
+    end
+
+    it "returns nil for the source options versions not included" do
+      expect(cookbook_source.source_options_for("cookbookA", "1.0.0")).to eq(nil)
+    end
+
+    it "returns the correct source options when the cookbook is included" do
+      expect(cookbook_source.source_options_for("cookbookA", "2.0.0")).to eq({ version: "2.0.0" })
+      expect(cookbook_source.source_options_for("cookbookB", "1.0.0")).to eq({ version: "1.0.0" })
+    end
+
+    it "has a universe with the used cookbooks" do
+      expect(cookbook_source.universe_graph).to eq({
+        "cookbookA" => {
+          "2.0.0" => external_cookbook_universe["cookbookA"]["2.0.0"],
+        },
+        "cookbookB" => {
+          "1.0.0" => external_cookbook_universe["cookbookB"]["1.0.0"],
+        },
+      })
+    end
+  end
+
+  context "when multiple policies are to be included" do
+    let(:policyfiles) { [policy1_location_spec, policy2_location_spec] }
+
+    context "when the policies use the same cookbooks with the same versions and sources" do
+      let(:policy2_cookbooks) { policy1_cookbooks + [{ name: "cookbookC", version: "2.0.0" }] }
+
+      it "has a preferred source for the included cookbooks" do
+        expect(cookbook_source.preferred_source_for?("cookbookA")).to eq(true)
+        expect(cookbook_source.preferred_source_for?("cookbookB")).to eq(true)
+        expect(cookbook_source.preferred_source_for?("cookbookC")).to eq(true)
+      end
+
+      it "returns the correct source options when the cookbook is included" do
+        expect(cookbook_source.source_options_for("cookbookA", "2.0.0")).to eq({ version: "2.0.0" })
+        expect(cookbook_source.source_options_for("cookbookB", "1.0.0")).to eq({ version: "1.0.0" })
+      end
+
+      it "has a universe with the used cookbooks" do
+        expect(cookbook_source.universe_graph).to eq({
+          "cookbookA" => {
+            "2.0.0" => external_cookbook_universe["cookbookA"]["2.0.0"],
+          },
+          "cookbookB" => {
+            "1.0.0" => external_cookbook_universe["cookbookB"]["1.0.0"],
+          },
+          "cookbookC" => {
+            "2.0.0" => external_cookbook_universe["cookbookC"]["2.0.0"],
+          },
+        })
+      end
+    end
+
+    context "when the policies have the same versions with conflicting sources" do
+      let(:randomize_sources) { true }
+      let(:policy2_cookbooks) { policy1_cookbooks }
+
+      it "raises an error when check_for_conflicts! is called" do
+        expect { cookbook_source.check_for_conflicts! }.to raise_error(
+          ChefCLI::Policyfile::IncludedPoliciesCookbookSource::ConflictingCookbookSources)
+      end
+    end
+
+    context "when the policies have conflicting versions" do
+      let(:policy2_cookbooks) { [{ name: "cookbookA", version: "1.0.0" }] }
+
+      it "raises an error when check_for_conflicts! is called" do
+        expect { cookbook_source.check_for_conflicts! }.to raise_error(
+          ChefCLI::Policyfile::IncludedPoliciesCookbookSource::ConflictingCookbookVersions)
+      end
+    end
+
+    context "when the policies have conflicting dependencies" do
+      it "raises an error when check_for_conflicts! is called"
+    end
+  end
+end

data/spec/unit/policyfile/lister_spec.rb

@@ -0,0 +1,268 @@
+#
+# Copyright:: Copyright (c) 2015 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-cli/policyfile/lister"
+
+describe ChefCLI::Policyfile::Lister do
+
+  def api_url(org_specific_path)
+    "https://chef.example/organizations/myorg/#{org_specific_path}"
+  end
+
+  let(:config) do
+    double("Chef::Config",
+           chef_server_url: "https://localhost:10443",
+           client_key: "/path/to/client/key.pem",
+           node_name: "deuce")
+  end
+
+  let(:http_client) { instance_double(Chef::ServerAPI) }
+
+  subject(:info_fetcher) do
+    described_class.new(config: config)
+  end
+
+  it "configures an HTTP client" do
+    expect(Chef::ServerAPI).to receive(:new).with("https://localhost:10443",
+                                                       signing_key_filename: "/path/to/client/key.pem",
+                                                       client_name: "deuce")
+    info_fetcher.http_client
+  end
+
+  context "when the data is fetched successfully from the server" do
+
+    before do
+      allow(info_fetcher).to receive(:http_client).and_return(http_client)
+
+      allow(http_client).to receive(:get).with("policy_groups").and_return(policy_group_list_data)
+      allow(http_client).to receive(:get).with("policies").and_return(policy_list_data)
+    end
+
+    context "when the server has no policies or groups" do
+
+      let(:policy_group_list_data) { {} }
+      let(:policy_list_data) { {} }
+
+      it "gives a Hash of policy revisions by policy name" do
+        expect(info_fetcher.policies_by_name).to eq({})
+      end
+
+      it "gives a Hash of policy revisions by policy group" do
+        expect(info_fetcher.policies_by_group).to eq({})
+      end
+
+      it "is empty" do
+        expect(info_fetcher).to be_empty
+      end
+
+      it "has no active revisions" do
+        expect(info_fetcher.active_revisions).to be_empty
+      end
+    end
+
+    context "when the server has policies and groups" do
+      ##
+      # Example API response data copied from oc-chef-pedant:
+
+      let(:policy_list_data) do
+        {
+          "appserver" => {
+            "uri" => api_url("policies/appserver"),
+            "revisions" => {
+              "1111111111111111111111111111111111111111" => {},
+              "2222222222222222222222222222222222222222" => {},
+              "3333333333333333333333333333333333333333" => {},
+              "4444444444444444444444444444444444444444" => {},
+            },
+          },
+          "db" => {
+            "uri" => api_url("policies/db"),
+            "revisions" => {
+              "6666666666666666666666666666666666666666" => {},
+              "7777777777777777777777777777777777777777" => {},
+              "8888888888888888888888888888888888888888" => {},
+              "9999999999999999999999999999999999999999" => {},
+            },
+          },
+          "cache" => {
+            "uri" => api_url("policies/cache"),
+            "revisions" => {
+              "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" => {},
+              "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" => {},
+            },
+          },
+        }
+      end
+
+      let(:dev_group_data) do
+        {
+          "uri" => api_url("policy_groups/dev"),
+          "policies" => {
+            "db" => { "revision_id" => "6666666666666666666666666666666666666666" },
+            "appserver" => { "revision_id" => "1111111111111111111111111111111111111111" },
+            "cache" => { "revision_id" => "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" },
+          },
+        }
+      end
+
+      let(:test_group_data) do
+        {
+          "uri" => api_url("policy_groups/test"),
+          "policies" => {
+            "db" => { "revision_id" => "7777777777777777777777777777777777777777" },
+            "appserver" => { "revision_id" => "2222222222222222222222222222222222222222" },
+            "cache" => { "revision_id" => "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" },
+          },
+        }
+      end
+
+      let(:prod_group_data) do
+        {
+          "uri" => api_url("policy_groups/prod"),
+          "policies" => {
+            "db" => { "revision_id" => "8888888888888888888888888888888888888888" },
+            "appserver" => { "revision_id" => "3333333333333333333333333333333333333333" },
+          },
+        }
+      end
+
+      let(:policy_group_list_data) do
+        {
+          "dev" => dev_group_data,
+          "test" => test_group_data,
+          "prod" => prod_group_data,
+        }
+      end
+
+      let(:expected_policy_list) do
+        {
+          "appserver" => {
+            "1111111111111111111111111111111111111111" => {},
+            "2222222222222222222222222222222222222222" => {},
+            "3333333333333333333333333333333333333333" => {},
+            "4444444444444444444444444444444444444444" => {},
+          },
+          "db" => {
+            "6666666666666666666666666666666666666666" => {},
+            "7777777777777777777777777777777777777777" => {},
+            "8888888888888888888888888888888888888888" => {},
+            "9999999999999999999999999999999999999999" => {},
+          },
+          "cache" => {
+            "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" => {},
+            "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" => {},
+          },
+        }
+      end
+
+      let(:expected_policy_group_list) do
+        {
+          "dev" => {
+            "db" => "6666666666666666666666666666666666666666",
+            "appserver" => "1111111111111111111111111111111111111111",
+            "cache" => "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          },
+          "test" => {
+            "db" => "7777777777777777777777777777777777777777",
+            "appserver" => "2222222222222222222222222222222222222222",
+            "cache" => "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+          },
+          "prod" => {
+            "db" => "8888888888888888888888888888888888888888",
+            "appserver" => "3333333333333333333333333333333333333333",
+          },
+        }
+      end
+
+      it "gives a Hash of policy revisions by policy name" do
+        expect(info_fetcher.policies_by_name).to eq(expected_policy_list)
+      end
+
+      it "gives a Hash of policy revisions by policy group" do
+        expect(info_fetcher.policies_by_group).to eq(expected_policy_group_list)
+      end
+
+      it "is not empty" do
+        expect(info_fetcher).to_not be_empty
+      end
+
+      it "lists active revisions" do
+        expected_active_revisions = expected_policy_group_list.values.map(&:values).flatten
+
+        expected_active_revisions_set = Set.new(expected_active_revisions)
+        expect(info_fetcher.active_revisions).to eq(expected_active_revisions_set)
+      end
+
+      it "lists orphaned revisions for a given policy" do
+        expect(info_fetcher.orphaned_revisions("db")).to eq(%w{ 9999999999999999999999999999999999999999 })
+        expect(info_fetcher.orphaned_revisions("appserver")).to eq(%w{ 4444444444444444444444444444444444444444 })
+        expect(info_fetcher.orphaned_revisions("cache")).to eq([])
+      end
+
+      it "yields revision ids by group" do
+        map = {}
+
+        info_fetcher.revision_ids_by_group_for_each_policy do |policy_name, rev_id_by_group|
+          map[policy_name] = rev_id_by_group
+        end
+
+        appserver_rev_ids = {
+          "dev" => "1111111111111111111111111111111111111111",
+          "test" => "2222222222222222222222222222222222222222",
+          "prod" => "3333333333333333333333333333333333333333",
+        }
+
+        expect(map["appserver"].revision_ids_by_group).to eq(appserver_rev_ids)
+
+        db_rev_ids = {
+          "dev" => "6666666666666666666666666666666666666666",
+          "test" => "7777777777777777777777777777777777777777",
+          "prod" => "8888888888888888888888888888888888888888",
+        }
+
+        expect(map["db"].revision_ids_by_group).to eq(db_rev_ids)
+
+        cache_rev_ids = {
+          "dev" => "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "test" => "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+          "prod" => nil,
+        }
+        expect(map["cache"].revision_ids_by_group).to eq(cache_rev_ids)
+      end
+
+      context "when the server has an empty group" do
+
+        let(:dev_group_data) do
+          {
+            "uri" => api_url("policy_groups/dev"),
+          }
+        end
+
+        # Regression test: this exercises the case where the policy group data
+        # from the server has no "policies" key, which previously caused a NoMethodError.
+        it "correctly lists groups without policies" do
+          expect(info_fetcher.policies_by_group["dev"]).to eq({})
+        end
+
+      end
+
+    end
+
+  end
+
+end