chef-dk 0.2.0 → 0.2.1

data/spec/unit/policyfile/storage_config_spec.rb

@@ -0,0 +1,98 @@
+#
+# Copyright:: Copyright (c) 2014 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-dk/policyfile/storage_config'
+
+describe ChefDK::Policyfile::StorageConfig do
+
+  let(:config_options) { {} }
+
+  let(:storage_config) do
+    described_class.new(config_options)
+  end
+
+  context "with explicit path options" do
+
+    let(:cache_path) do
+      File.expand_path("spec/unit/fixtures/cookbook_cache", project_root)
+    end
+
+    let(:relative_paths_root) do
+      File.expand_path("spec/unit/fixtures/", project_root)
+    end
+
+    let(:config_options) do
+      { cache_path: cache_path, relative_paths_root: relative_paths_root }
+    end
+
+    it "uses the provided option for relative_paths_root" do
+      expect(storage_config.relative_paths_root).to eq(relative_paths_root)
+    end
+
+    it "uses the provided cache_path" do
+      expect(storage_config.cache_path).to eq(cache_path)
+    end
+  end
+
+  context "with default options" do
+
+    it "defaults to the CookbookOmnifetch configured cache path" do
+      expect(storage_config.cache_path).to eq(CookbookOmnifetch.storage_path)
+    end
+
+    it "defaults to the current working directory for relative_paths_root" do
+      expect(storage_config.relative_paths_root).to eq(Dir.pwd)
+    end
+  end
+
+  describe "updating storage config for policyfile location" do
+
+    before do
+      storage_config.use_policyfile("/path/to/Policyfile.rb")
+    end
+
+    it "updates the relative_paths_root to be relative to a policyfile" do
+      expect(storage_config.relative_paths_root).to eq("/path/to")
+    end
+
+    it "stores the location of the policyfile" do
+      expect(storage_config.policyfile_filename).to eq("/path/to/Policyfile.rb")
+    end
+
+  end
+
+
+  describe "updating storage config for policyfile lock location" do
+
+    before do
+      storage_config.use_policyfile_lock("/path/to/Policyfile.lock.json")
+    end
+
+    it "updates the relative_paths_root to be relative to a policyfile" do
+      expect(storage_config.relative_paths_root).to eq("/path/to")
+    end
+
+    it "stores the location of the policyfile" do
+      expect(storage_config.policyfile_lock_filename).to eq("/path/to/Policyfile.lock.json")
+    end
+
+  end
+
+
+end
+

data/spec/unit/policyfile/uploader_spec.rb

@@ -0,0 +1,292 @@
+#
+# Copyright:: Copyright (c) 2014 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-dk/policyfile/uploader'
+
+# We load this here to ensure we get the "verifying doubles" behavior from
+# RSpec. It's not used by Policyfile::Uploader, but it's a collaborator.
+require 'chef-dk/authenticated_http'
+
+describe ChefDK::Policyfile::Uploader do
+
+  let(:policyfile_lock_data) do
+    {
+      "name"=> "example",
+      "run_list"=> [ "recipe[omnibus::default]" ],
+      "cookbook_locks"=> {
+        "omnibus"=> {
+          "version"=> "2.2.0",
+          "identifier"=> "64b3e64306cff223206348e46af545b19032b170",
+          "dotted_decimal_identifier"=> "28345299219435506.9887234981653237.76628930769264",
+          "cache_key"=> "omnibus-2cf98f9797cacce9c8688fc4e74858b858e2bc14",
+          "origin"=> "git@github.com:opscode-cookbooks/omnibus.git",
+          "source_options"=> {
+            "git"=> "git@github.com:opscode-cookbooks/omnibus.git",
+            "revision"=> "2cf98f9797cacce9c8688fc4e74858b858e2bc14",
+            "branch"=> "master"
+          }
+        }
+      }
+    }
+  end
+
+  let(:policyfile_lock) { instance_double("ChefDK::PolicyfileLock", name: "example",
+                                                                    to_lock: policyfile_lock_data) }
+
+  let(:policy_group) { "unit-test" }
+
+  let(:http_client) { instance_double("ChefDK::AuthenticatedHTTP") }
+
+  let(:uploader) { described_class.new(policyfile_lock, policy_group, http_client: http_client) }
+
+  let(:policyfile_as_data_bag_item) do
+
+    policyfile_as_data_bag_item = {
+      "id" => "example-unit-test",
+      "name" => "data_bag_item_policyfiles_example-unit-test",
+      "data_bag" => "policyfiles"
+    }
+    policyfile_as_data_bag_item["raw_data"] = policyfile_lock_data.dup
+    policyfile_as_data_bag_item["raw_data"]["id"] = "example-unit-test"
+    policyfile_as_data_bag_item["json_class"] = "Chef::DataBagItem"
+    policyfile_as_data_bag_item
+  end
+
+  it "has a lockfile" do
+    expect(uploader.policyfile_lock).to eq(policyfile_lock)
+  end
+
+  it "has a policy group" do
+    expect(uploader.policy_group).to eq(policy_group)
+  end
+
+  it "has an HTTP client" do
+    expect(uploader.http_client).to eq(http_client)
+  end
+
+  context "when created without an HTTP client" do
+
+    let(:http_client) { nil }
+
+    it "creates an HTTP client with default config" do
+      skip "TODO: determine correct behavior"
+    end
+
+  end
+
+
+  describe "creating uploading documents in compat mode" do
+
+    let(:cookbook_locks) { {} }
+    let(:cookbook_versions) { {} }
+
+    let(:existing_cookbook_on_remote) do
+      {"apt"=>
+        {"url"=>"http://localhost:8889/cookbooks/apt",
+         "versions"=>
+          [{"url"=>
+             "http://localhost:8889/cookbooks/apt/46097674477573307.43471642740453733.243606720748315",
+            "version"=>"46097674477573307.43471642740453733.243606720748315"}]},
+       "build-essential"=>
+        {"url"=>"http://localhost:8889/cookbooks/build-essential",
+         "versions"=>
+          [{"url"=>
+             "http://localhost:8889/cookbooks/build-essential/67369247788170534.26353953100055918.55660493423796",
+            "version"=>"67369247788170534.26353953100055918.55660493423796"}]},
+       "java"=>
+        {"url"=>"http://localhost:8889/cookbooks/java",
+         "versions"=>
+          [{"url"=>
+             "http://localhost:8889/cookbooks/java/5664982062912610.52588194571203830.6215746262253",
+            "version"=>"5664982062912610.52588194571203830.6215746262253"}]},
+       "jenkins"=>
+        {"url"=>"http://localhost:8889/cookbooks/jenkins",
+         "versions"=>
+          [{"url"=>
+             "http://localhost:8889/cookbooks/jenkins/69194928762630300.30177357398946006.269829039948647",
+            "version"=>"69194928762630300.30177357398946006.269829039948647"}]}
+      }
+    end
+
+    before do
+      allow(policyfile_lock).to receive(:cookbook_locks).and_return(cookbook_locks)
+    end
+
+    def lock_double(name, dotted_decimal_id)
+      cache_path = "/home/user/cache_path/#{name}"
+
+      lock = instance_double("ChefDK::Policyfile::CookbookLock",
+                             name: name,
+                             dotted_decimal_identifier: dotted_decimal_id,
+                             cookbook_path: cache_path)
+
+      cookbook_version = instance_double("Chef::CookbookVersion",
+                                         name: name,
+                                         version: dotted_decimal_id)
+
+      allow(ChefDK::Policyfile::ReadCookbookForCompatModeUpload).
+        to receive(:load).
+        with(name, dotted_decimal_id, cache_path).
+        and_return(cookbook_version)
+
+      cookbook_versions[name] = cookbook_version
+      cookbook_locks[name] = lock
+
+      lock
+    end
+
+    it "ensures a data bag named 'policyfiles' exists" do
+      expect(http_client).to receive(:post).with('data', {"name" => "policyfiles"})
+      uploader.data_bag_create
+    end
+
+    it "does not error when the 'policyfiles' data bag exists" do
+      response = double("Net::HTTP response", code: "409")
+      error = Net::HTTPServerException.new("conflict", response)
+      expect(http_client).to receive(:post).with('data', {"name" => "policyfiles"}).and_raise(error)
+      expect { uploader.data_bag_create }.to_not raise_error
+    end
+
+    it "uploads the policyfile as a data bag item" do
+      response = double("Net::HTTP response", code: "404")
+      error = Net::HTTPServerException.new("Not Found", response)
+      expect(http_client).to receive(:put).
+        with('data/policyfiles/example-unit-test', policyfile_as_data_bag_item).
+        and_raise(error)
+      expect(http_client).to receive(:post).
+        with('data/policyfiles', policyfile_as_data_bag_item)
+
+      uploader.data_bag_item_create
+    end
+
+    it "replaces an existing policyfile on the server if it exists" do
+      expect(http_client).to receive(:put).
+        with('data/policyfiles/example-unit-test', policyfile_as_data_bag_item)
+
+      uploader.data_bag_item_create
+    end
+
+    it "enumerates the cookbooks already on the server" do
+      expect(http_client).to receive(:get).with('cookbooks?num_versions=all').and_return(existing_cookbook_on_remote)
+      expect(uploader.existing_cookbook_on_remote).to eq(existing_cookbook_on_remote)
+    end
+
+    context "with an empty policyfile lock" do
+
+      it "has an empty list of cookbooks for possible upload" do
+        expect(policyfile_lock).to receive(:validate_cookbooks!)
+
+        expect(uploader.cookbook_versions_for_policy).to eq([])
+      end
+
+      it "has an empty list of cookbooks that need to be uploaded" do
+        expect(policyfile_lock).to receive(:validate_cookbooks!)
+
+        expect(uploader.cookbook_versions_to_upload).to eq([])
+      end
+
+    end
+
+    context "with a set of cookbooks that don't exist on the server" do
+
+      before do
+        lock_double("my_apache2", "123.456.789")
+        lock_double("my_jenkins", "321.654.987")
+      end
+
+      it "lists the cookbooks in the lock as possibly needing to be uploaded" do
+        expect(policyfile_lock).to receive(:validate_cookbooks!)
+
+        expect(uploader.cookbook_versions_for_policy).to eq(cookbook_versions.values)
+      end
+
+      it "lists all cookbooks in the lock as needing to be uploaded" do
+        expect(policyfile_lock).to receive(:validate_cookbooks!)
+        expect(http_client).to receive(:get).with('cookbooks?num_versions=all').and_return(existing_cookbook_on_remote)
+
+        expect(uploader.cookbook_versions_to_upload).to eq(cookbook_versions.values)
+      end
+
+      it "uploads the cookbooks and then the policy" do
+        expect(policyfile_lock).to receive(:validate_cookbooks!)
+        expect(http_client).to receive(:get).with('cookbooks?num_versions=all').and_return(existing_cookbook_on_remote)
+
+        cookbook_uploader = instance_double("Chef::CookbookUploader")
+        expect(Chef::CookbookUploader).to receive(:new).
+          with(cookbook_versions.values, :rest => http_client).
+          and_return(cookbook_uploader)
+        expect(cookbook_uploader).to receive(:upload_cookbooks)
+
+        # behavior for these tested above
+        expect(uploader).to receive(:data_bag_create)
+        expect(uploader).to receive(:data_bag_item_create)
+
+        uploader.upload
+      end
+
+    end
+
+    context "with a set of cookbooks where some already exist on the server" do
+
+      before do
+        # These are new:
+        lock_double("my_apache2", "123.456.789")
+        lock_double("my_jenkins", "321.654.987")
+
+        # Have this one:
+        lock_double("build-essential", "67369247788170534.26353953100055918.55660493423796")
+      end
+
+      let(:expected_cookbooks_for_upload) do
+        [
+          cookbook_versions["my_apache2"],
+          cookbook_versions["my_jenkins"]
+        ]
+      end
+
+      it "lists only cookbooks not on the server as needing to be uploaded" do
+        expect(policyfile_lock).to receive(:validate_cookbooks!)
+        expect(http_client).to receive(:get).with('cookbooks?num_versions=all').and_return(existing_cookbook_on_remote)
+
+
+        expect(uploader.cookbook_versions_to_upload).to eq(expected_cookbooks_for_upload)
+      end
+
+      it "uploads the cookbooks and then the policy" do
+        expect(policyfile_lock).to receive(:validate_cookbooks!)
+        expect(http_client).to receive(:get).with('cookbooks?num_versions=all').and_return(existing_cookbook_on_remote)
+
+        cookbook_uploader = instance_double("Chef::CookbookUploader")
+        expect(Chef::CookbookUploader).to receive(:new).
+          with(expected_cookbooks_for_upload, :rest => http_client).
+          and_return(cookbook_uploader)
+        expect(cookbook_uploader).to receive(:upload_cookbooks)
+
+        # behavior for these tested above
+        expect(uploader).to receive(:data_bag_create)
+        expect(uploader).to receive(:data_bag_item_create)
+
+        uploader.upload
+      end
+
+    end
+
+  end
+
+end
+

data/spec/unit/policyfile_demands_spec.rb

@@ -29,8 +29,6 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
   let(:policyfile) do
     policyfile = ChefDK::PolicyfileCompiler.new.build do |p|
 
-      p.policyfile_filename = "/no-such-place/Policyfile.rb"
-
       p.default_source(*default_source) if default_source
       p.run_list(*run_list)
 
@@ -128,6 +126,29 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
     end
   end
 
+  describe "when normalizing run_list items" do
+
+    it "normalizes a bare cookbook name" do
+      policyfile.run_list("local-cookbook")
+      expect(policyfile.normalized_run_list).to eq(["recipe[local-cookbook::default]"])
+    end
+
+    it "normalizes a bare cookbook::recipe item" do
+      policyfile.run_list("local-cookbook::server")
+      expect(policyfile.normalized_run_list).to eq(["recipe[local-cookbook::server]"])
+    end
+
+    it "normalizes a recipe[] item with implicit default" do
+      policyfile.run_list("recipe[local-cookbook]")
+      expect(policyfile.normalized_run_list).to eq(["recipe[local-cookbook::default]"])
+    end
+
+    it "does not modify a fully qualified recipe" do
+      policyfile.run_list("recipe[local-cookbook::jazz_hands]")
+      expect(policyfile.normalized_run_list).to eq(["recipe[local-cookbook::jazz_hands]"])
+    end
+
+  end
 
   before do
     expect(policyfile.errors).to eq([])
@@ -149,6 +170,14 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
       expect(policyfile).to receive(:ensure_cache_dir_exists)
       expect(policyfile.graph_solution).to eq({})
     end
+
+    it "has an empty set of solution_dependencies" do
+      expected_solution_deps = {
+        "Policyfile" => [],
+        "dependencies" => {}
+      }
+      expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+    end
   end
 
   context "Given a run list and no local or git cookbooks" do
@@ -172,6 +201,14 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
         expect(policyfile.graph_solution).to eq({"remote-cb" => "1.1.1"})
       end
 
+      it "includes the cookbook in the solution dependencies" do
+        expected_solution_deps = {
+          "Policyfile" => [],
+          "dependencies" => { "remote-cb (1.1.1)" => [] }
+        }
+        expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+      end
+
     end
 
     context "And the default source is the chef-server" do
@@ -199,8 +236,9 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
 
     before do
       policyfile.dsl.cookbook('local-cookbook', path: "/foo")
-      policyfile.cookbook_spec_for("local-cookbook").stub(:version).and_return("2.3.4")
-      policyfile.cookbook_spec_for("local-cookbook").stub(:dependencies).and_return([])
+      allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:version).and_return("2.3.4")
+      allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:dependencies).and_return([])
+      allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:ensure_cached).and_return(true)
     end
 
     it "demands a solution using the local cookbook" do
@@ -214,6 +252,14 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
       expect(policyfile.artifacts_graph).to eq(expected_artifacts_graph)
     end
 
+    it "includes the cookbook in the solution dependencies" do
+      expected_solution_deps = {
+        "Policyfile" => [ [ "local-cookbook", ">= 0.0.0" ] ],
+        "dependencies" => { "local-cookbook (2.3.4)" => [] }
+      }
+      expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+    end
+
   end
 
   context "Given a local cookbook with a dependency and only the local cookbook in the run list" do
@@ -226,9 +272,9 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
 
       before do
         policyfile.dsl.cookbook("local-cookbook", path: "foo/")
-        policyfile.cookbook_spec_for("local-cookbook").stub(:ensure_cached)
-        policyfile.cookbook_spec_for("local-cookbook").stub(:version).and_return("2.3.4")
-        policyfile.cookbook_spec_for("local-cookbook").stub(:dependencies).and_return([ [ "local-cookbook-dep-one", "~> 1.0"] ])
+        allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:ensure_cached)
+        allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:version).and_return("2.3.4")
+        allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:dependencies).and_return([ [ "local-cookbook-dep-one", "~> 1.0"] ])
       end
 
       it "demands a solution using the local cookbook" do
@@ -248,6 +294,18 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
         expect(policyfile.graph_solution).to eq({"local-cookbook" => "2.3.4", "local-cookbook-dep-one" => "1.5.0"})
       end
 
+      it "includes the cookbook and dependencies in the solution dependencies" do
+        expected_solution_deps = {
+          "Policyfile" => [ [ "local-cookbook", ">= 0.0.0" ] ],
+          "dependencies" => {
+            "local-cookbook (2.3.4)" => [[ "local-cookbook-dep-one", "~> 1.0"]],
+            "local-cookbook-dep-one (1.5.0)" => []
+          }
+
+        }
+        expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+      end
+
     end
     context "And the default source is the chef server" do
 
@@ -255,9 +313,9 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
 
       before do
         policyfile.dsl.cookbook("local-cookbook", path: "foo/")
-        policyfile.cookbook_spec_for("local-cookbook").stub(:ensure_cached)
-        policyfile.cookbook_spec_for("local-cookbook").stub(:version).and_return("2.3.4")
-        policyfile.cookbook_spec_for("local-cookbook").stub(:dependencies).and_return([ [ "local-cookbook-dep-one", "~> 1.0"] ])
+        allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:ensure_cached)
+        allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:version).and_return("2.3.4")
+        allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:dependencies).and_return([ [ "local-cookbook-dep-one", "~> 1.0"] ])
       end
 
       it "demands a solution using the local cookbook" do
@@ -280,6 +338,18 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
         expect(policyfile.graph_solution).to eq({"local-cookbook" => "2.3.4", "local-cookbook-dep-one" => "1.6.0"})
       end
 
+      it "includes the cookbook and dependencies in the solution dependencies" do
+        expected_solution_deps = {
+          "Policyfile" => [ [ "local-cookbook", ">= 0.0.0" ] ],
+          "dependencies" => {
+            "local-cookbook (2.3.4)" => [[ "local-cookbook-dep-one", "~> 1.0"]],
+            "local-cookbook-dep-one (1.6.0)" => []
+          }
+
+        }
+        expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+      end
+
     end
   end
 
@@ -289,9 +359,9 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
 
     before do
       policyfile.dsl.cookbook("git-sourced-cookbook", git: "git://git.example.org:user/a-cookbook.git")
-      policyfile.cookbook_spec_for("git-sourced-cookbook").stub(:ensure_cached)
-      policyfile.cookbook_spec_for("git-sourced-cookbook").stub(:version).and_return("8.6.7")
-      policyfile.cookbook_spec_for("git-sourced-cookbook").stub(:dependencies).and_return([ ])
+      allow(policyfile.cookbook_location_spec_for("git-sourced-cookbook")).to receive(:ensure_cached)
+      allow(policyfile.cookbook_location_spec_for("git-sourced-cookbook")).to receive(:version).and_return("8.6.7")
+      allow(policyfile.cookbook_location_spec_for("git-sourced-cookbook")).to receive(:dependencies).and_return([ ])
     end
 
     it "demands a solution using the git sourced cookbook" do
@@ -309,6 +379,18 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
       expect(policyfile).to receive(:ensure_cache_dir_exists)
       expect(policyfile.graph_solution).to eq({"git-sourced-cookbook" => "8.6.7"})
     end
+
+    it "includes the cookbook and dependencies in the solution dependencies" do
+      expected_solution_deps = {
+        "Policyfile" => [ [ "git-sourced-cookbook", ">= 0.0.0" ] ],
+        "dependencies" => {
+          "git-sourced-cookbook (8.6.7)" => []
+        }
+
+      }
+      expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+    end
+
   end
 
   context "Given a git-sourced cookbook with a dependency and only the git cookbook in the run list" do
@@ -317,9 +399,9 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
 
     before do
       policyfile.dsl.cookbook("git-sourced-cookbook", git: "git://git.example.org:user/a-cookbook.git")
-      policyfile.cookbook_spec_for("git-sourced-cookbook").stub(:ensure_cached)
-      policyfile.cookbook_spec_for("git-sourced-cookbook").stub(:version).and_return("8.6.7")
-      policyfile.cookbook_spec_for("git-sourced-cookbook").stub(:dependencies).and_return([ ["git-sourced-cookbook-dep", "~> 2.2" ] ])
+      allow(policyfile.cookbook_location_spec_for("git-sourced-cookbook")).to receive(:ensure_cached)
+      allow(policyfile.cookbook_location_spec_for("git-sourced-cookbook")).to receive(:version).and_return("8.6.7")
+      allow(policyfile.cookbook_location_spec_for("git-sourced-cookbook")).to receive(:dependencies).and_return([ ["git-sourced-cookbook-dep", "~> 2.2" ] ])
     end
 
     context "And the default source is the community site" do
@@ -342,6 +424,19 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
         expect(policyfile).to receive(:ensure_cache_dir_exists)
         expect(policyfile.graph_solution).to eq({"git-sourced-cookbook" => "8.6.7", "git-sourced-cookbook-dep" => "2.8.0"})
       end
+
+      it "includes the cookbook and dependencies in the solution dependencies" do
+        expected_solution_deps = {
+          "Policyfile" => [ [ "git-sourced-cookbook", ">= 0.0.0" ] ],
+          "dependencies" => {
+            "git-sourced-cookbook (8.6.7)" => [ [ "git-sourced-cookbook-dep", "~> 2.2" ] ],
+            "git-sourced-cookbook-dep (2.8.0)" => []
+          }
+
+        }
+        expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+      end
+
     end
 
     context "And the default source is the chef server" do
@@ -364,6 +459,19 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
         expect(policyfile).to receive(:ensure_cache_dir_exists)
         expect(policyfile.graph_solution).to eq({"git-sourced-cookbook" => "8.6.7", "git-sourced-cookbook-dep" => "2.9.0"})
       end
+
+      it "includes the cookbook and dependencies in the solution dependencies" do
+        expected_solution_deps = {
+          "Policyfile" => [ [ "git-sourced-cookbook", ">= 0.0.0" ] ],
+          "dependencies" => {
+            "git-sourced-cookbook (8.6.7)" => [ [ "git-sourced-cookbook-dep", "~> 2.2" ] ],
+            "git-sourced-cookbook-dep (2.9.0)" => []
+          }
+
+        }
+        expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+      end
+
     end
   end
 
@@ -373,9 +481,9 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
 
     before do
       policyfile.dsl.cookbook("local-cookbook", path: "foo/")
-      policyfile.cookbook_spec_for("local-cookbook").stub(:ensure_cached)
-      policyfile.cookbook_spec_for("local-cookbook").stub(:version).and_return("2.3.4")
-      policyfile.cookbook_spec_for("local-cookbook").stub(:dependencies).and_return([])
+      allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:ensure_cached)
+      allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:version).and_return("2.3.4")
+      allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:dependencies).and_return([])
     end
 
     context "And the default source is the community site" do
@@ -397,6 +505,18 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
         expect(policyfile.graph_solution).to eq({"local-cookbook" => "2.3.4", "remote-cb" => "1.1.1"})
       end
 
+      it "includes the cookbook and dependencies in the solution dependencies" do
+        expected_solution_deps = {
+          "Policyfile" => [ [ "local-cookbook", ">= 0.0.0" ] ],
+          "dependencies" => {
+            "local-cookbook (2.3.4)" => [],
+            "remote-cb (1.1.1)" => []
+          }
+
+        }
+        expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+      end
+
     end
 
     context "And the default source is the chef server" do
@@ -418,6 +538,18 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
         expect(policyfile.graph_solution).to eq({"local-cookbook" => "2.3.4", "remote-cb" => "1.1.1"})
       end
 
+      it "includes the cookbook and dependencies in the solution dependencies" do
+        expected_solution_deps = {
+          "Policyfile" => [ [ "local-cookbook", ">= 0.0.0" ] ],
+          "dependencies" => {
+            "local-cookbook (2.3.4)" => [],
+            "remote-cb (1.1.1)" => []
+          }
+
+        }
+        expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+      end
+
     end
   end
 
@@ -440,6 +572,16 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
       expect(policyfile.graph_solution).to eq({"remote-cb" => "0.1.0"})
     end
 
+    it "includes the policyfile constraint in the solution dependencies" do
+      expected_solution_deps = {
+        "Policyfile" => [ [ "remote-cb", "~> 0.1" ] ],
+        "dependencies" => {
+          "remote-cb (0.1.0)" => []
+        }
+
+      }
+      expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+    end
   end
 
   context "given a cookbook that isn't in the run list is specified with a version constraint in the policyfile" do
@@ -453,9 +595,9 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
 
       policyfile.dsl.cookbook("local-cookbook", path: "foo/")
 
-      policyfile.cookbook_spec_for("local-cookbook").stub(:ensure_cached)
-      policyfile.cookbook_spec_for("local-cookbook").stub(:version).and_return("2.3.4")
-      policyfile.cookbook_spec_for("local-cookbook").stub(:dependencies).and_return([])
+      allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:ensure_cached)
+      allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:version).and_return("2.3.4")
+      allow(policyfile.cookbook_location_spec_for("local-cookbook")).to receive(:dependencies).and_return([])
     end
 
     it "demands a solution that matches the version constraint in the policyfile" do
@@ -468,16 +610,27 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
     end
 
     it "builds a policyfile lock from the constraints" do
-      pending
+      skip
       expect(policyfile).to receive(:cache_path).and_return(Pathname.new("~/.nopenope/cache"))
       expect(policyfile.lock).to eq(:wat)
     end
 
+    it "includes the policyfile constraint in the solution dependencies" do
+      expected_solution_deps = {
+        "Policyfile" => [ [ "remote-cb", "~> 0.1" ], [ "local-cookbook", ">= 0.0.0"] ],
+        "dependencies" => {
+          "local-cookbook (2.3.4)" => [],
+          "remote-cb (0.1.0)" => []
+        }
+
+      }
+      expect(policyfile.solution_dependencies.to_lock).to eq(expected_solution_deps)
+    end
   end
 
   context "Given a run_list with roles" do
     it "expands the roles from the given role source" do
-      pending
+      skip
     end
   end