chef-dk 0.3.5 → 0.4.0

data/spec/unit/policyfile_demands_spec.rb

@@ -148,6 +148,29 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
       expect(policyfile.normalized_run_list).to eq(["recipe[local-cookbook::jazz_hands]"])
     end
 
+    describe "in an alternate run list" do
+
+      it "normalizes a bare cookbook name" do
+        policyfile.named_run_list(:foo, "local-cookbook")
+        expect(policyfile.normalized_named_run_lists[:foo]).to eq(["recipe[local-cookbook::default]"])
+      end
+
+      it "normalizes a bare cookbook::recipe item" do
+        policyfile.named_run_list(:foo, "local-cookbook::server")
+        expect(policyfile.normalized_named_run_lists[:foo]).to eq(["recipe[local-cookbook::server]"])
+      end
+
+      it "normalizes a recipe[] item with implicit default" do
+        policyfile.named_run_list(:foo, "recipe[local-cookbook]")
+        expect(policyfile.normalized_named_run_lists[:foo]).to eq(["recipe[local-cookbook::default]"])
+      end
+
+      it "does not modify a fully qualified recipe" do
+        policyfile.named_run_list(:foo, "recipe[local-cookbook::jazz_hands]")
+        expect(policyfile.normalized_named_run_lists[:foo]).to eq(["recipe[local-cookbook::jazz_hands]"])
+      end
+
+    end
   end
 
   before do
@@ -628,6 +651,30 @@ describe ChefDK::PolicyfileCompiler, "when expressing the Policyfile graph deman
     end
   end
 
+  context "Given a run_list and named run_lists" do
+
+    before do
+      policyfile.dsl.named_run_list(:foo, 'local-cookbook', 'nginx')
+      policyfile.dsl.named_run_list(:bar, 'remote-cb', 'nginx')
+      policyfile.dsl.run_list('private-cookbook', 'nginx')
+    end
+
+    it "demands a solution that satisfies all of the run lists, with no duplicates" do
+      expect(policyfile.graph_demands).to include(["private-cookbook", ">= 0.0.0"])
+      expect(policyfile.graph_demands).to include(["nginx", ">= 0.0.0"])
+      expect(policyfile.graph_demands).to include(["remote-cb", ">= 0.0.0"])
+      expect(policyfile.graph_demands).to include(["local-cookbook", ">= 0.0.0"])
+
+      # ensure there are no duplicates:
+      expected_demands = [["private-cookbook", ">= 0.0.0"],
+                          ["nginx", ">= 0.0.0"],
+                          ["local-cookbook", ">= 0.0.0"],
+                          ["remote-cb", ">= 0.0.0"]]
+      expect(policyfile.graph_demands).to eq(expected_demands)
+    end
+
+  end
+
   context "Given a run_list with roles" do
     it "expands the roles from the given role source" do
       skip

data/spec/unit/policyfile_evaluation_spec.rb

@@ -185,7 +185,7 @@ E
 
         it "has a default source" do
           expect(policyfile.errors).to eq([])
-          expected = ChefDK::Policyfile::CommunityCookbookSource.new("https://supermarket.getchef.com")
+          expected = ChefDK::Policyfile::CommunityCookbookSource.new("https://supermarket.chef.io")
           expect(policyfile.default_source).to eq(expected)
         end
 

data/spec/unit/policyfile_lock_build_spec.rb

@@ -341,7 +341,7 @@ describe ChefDK::PolicyfileLock, "building a lockfile" do
 
           # Optional attribute that humans can use to understand where a cookbook
           # came from.
-          cb.origin = "https://community.getchef.com/api/cookbooks/foo/1.0.0"
+          cb.origin = "https://community.chef.io/api/cookbooks/foo/1.0.0"
         end
 
         p.local_cookbook("bar") do |cb|
@@ -375,7 +375,7 @@ describe ChefDK::PolicyfileLock, "building a lockfile" do
             "version" => "1.0.0",
             "identifier" => cookbook_foo_cksum,
             "dotted_decimal_identifier" => cookbook_foo_cksum_dotted,
-            "origin" => "https://community.getchef.com/api/cookbooks/foo/1.0.0",
+            "origin" => "https://community.chef.io/api/cookbooks/foo/1.0.0",
             "cache_key" => "foo-1.0.0",
             "source_options" => nil
           },
@@ -492,6 +492,56 @@ describe ChefDK::PolicyfileLock, "building a lockfile" do
     end
 
   end
+
+  context "with named run_lists specified" do
+
+    let(:policyfile_lock) do
+      ChefDK::PolicyfileLock.build(storage_config) do |p|
+
+        p.name = "minimal_policyfile"
+
+        p.run_list = [ "recipe[foo]" ]
+
+        p.named_run_lists = { "rl2" => [ "recipe[foo::bar]" ] }
+
+        p.cached_cookbook("foo") do |cb|
+          cb.cache_key = "foo-1.0.0"
+        end
+
+      end
+    end
+
+    let(:compiled_policyfile) do
+      {
+
+        "name" => "minimal_policyfile",
+
+        "run_list" => ["recipe[foo]"],
+
+        "named_run_lists" => { "rl2" => [ "recipe[foo::bar]" ] },
+
+        "cookbook_locks" => {
+
+          "foo" => {
+            "version" => "1.0.0",
+            "identifier" => cookbook_foo_cksum,
+            "dotted_decimal_identifier" => cookbook_foo_cksum_dotted,
+            "cache_key" => "foo-1.0.0",
+            "origin" => nil,
+            "source_options" => nil
+          },
+        },
+
+        "solution_dependencies" => { "Policyfile" => [], "dependencies" => {} }
+      }
+    end
+
+    it "includes the named run lists in the compiled policyfile" do
+      expect(policyfile_lock.to_lock).to eq(compiled_policyfile)
+    end
+
+  end
+
   describe "building a policyfile lock from a policyfile compiler" do
 
     include_context "setup git cookbooks"
@@ -500,7 +550,7 @@ describe ChefDK::PolicyfileLock, "building a lockfile" do
       tempdir
     end
 
-    let(:cached_cookbook_uri) { "https://supermarket.getchef.com/api/v1/cookbooks/foo/versions/1.0.0/download" }
+    let(:cached_cookbook_uri) { "https://supermarket.chef.io/api/v1/cookbooks/foo/versions/1.0.0/download" }
 
     let(:cached_location_spec) do
       double( "ChefDK::Policyfile::CookbookLocationSpecification",
@@ -530,6 +580,7 @@ describe ChefDK::PolicyfileLock, "building a lockfile" do
       double( "ChefDK::PolicyfileCompiler",
               name: "my-policyfile",
               normalized_run_list: %w[recipe[foo::default] recipe[bar::default]],
+              normalized_named_run_lists: { "rl2" => %w[recipe[bar::default]] },
               all_cookbook_location_specs: {"foo" => cached_location_spec, "bar" => local_location_spec},
               solution_dependencies: policyfile_solution_dependencies )
     end
@@ -545,6 +596,8 @@ describe ChefDK::PolicyfileLock, "building a lockfile" do
 
         "run_list" => ["recipe[foo::default]", "recipe[bar::default]"],
 
+        "named_run_lists" => { "rl2" => ["recipe[bar::default]"] },
+
         "cookbook_locks" => {
 
           "foo" => {
@@ -595,6 +648,10 @@ describe ChefDK::PolicyfileLock, "building a lockfile" do
       expect(cb_lock.source).to eq(local_location_spec.relative_path)
     end
 
+    it "sets named run lists on the policyfile lock" do
+      expect(policyfile_lock.named_run_lists).to eq("rl2" => %w[recipe[bar::default]])
+    end
+
     it "generates a lockfile data structure" do
       expect(policyfile_lock.to_lock).to eq(compiled_policyfile)
     end

data/spec/unit/policyfile_services/export_repo_spec.rb

@@ -0,0 +1,321 @@
+#
+# 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_services/export_repo'
+
+describe ChefDK::PolicyfileServices::ExportRepo do
+
+  let(:working_dir) do
+    path = File.join(tempdir, "policyfile_services_test_working_dir")
+    Dir.mkdir(path)
+    path
+  end
+
+  let(:export_dir) { File.join(tempdir, "export_repo_export_dir") }
+
+  let(:policyfile_rb_explicit_name) { nil }
+
+  let(:policyfile_rb_name) { policyfile_rb_explicit_name || "Policyfile.rb" }
+
+  let(:expanded_policyfile_path) { File.join(working_dir, policyfile_rb_name) }
+
+  let(:policyfile_lock_name) { "Policyfile.lock.json" }
+
+  let(:policyfile_lock_path) { File.join(working_dir, policyfile_lock_name) }
+
+  let(:force_export) { false }
+
+  subject(:export_service) do
+    described_class.new(policyfile: policyfile_rb_explicit_name,
+                        root_dir: working_dir,
+                        export_dir: export_dir,
+                        force: force_export)
+  end
+
+  it "uses Policyfile.rb as the default Policyfile name" do
+    expect(export_service.policyfile_filename).to eq(expanded_policyfile_path)
+  end
+
+  context "when given an explicit Policyfile name" do
+
+    let(:policyfile_rb_explicit_name) { "MyPolicy.rb" }
+
+    it "uses the given Policyfile name" do
+      expect(export_service.policyfile_filename).to eq(expanded_policyfile_path)
+    end
+
+  end
+
+  it "has a destination directory for the export" do
+    expect(export_service.export_dir).to eq(export_dir)
+  end
+
+  context "when the policyfile lock is missing" do
+
+    it "raises an error that suggests you run `chef install'" do
+      expect { export_service.run }.to raise_error(ChefDK::LockfileNotFound)
+    end
+
+  end
+
+  context "when a lockfile is present" do
+
+    before do
+      File.open(policyfile_lock_path, "w+") { |f| f.print(lockfile_content) }
+    end
+
+    context "and the lockfile has invalid JSON" do
+
+      let(:lockfile_content) { ":::" }
+
+      it "errors out" do
+        expect { export_service.run }.to raise_error(ChefDK::PolicyfileExportRepoError, /Error reading lockfile/)
+      end
+
+    end
+
+    context "and the lockfile is semantically invalid" do
+
+      let(:lockfile_content) { '{ }' }
+
+      it "errors out" do
+        expect { export_service.run }.to raise_error(ChefDK::PolicyfileExportRepoError, /Invalid lockfile data/)
+      end
+
+    end
+
+    context "and the lockfile is valid" do
+
+      let(:local_cookbook_path) { File.join(fixtures_path, "local_path_cookbooks/local-cookbook") }
+
+      let(:lockfile_content) do
+        <<-E
+{
+  "name": "install-example",
+  "run_list": [
+    "recipe[local-cookbook::default]"
+  ],
+  "cookbook_locks": {
+    "local-cookbook": {
+      "version": "2.3.4",
+      "identifier": "fab501cfaf747901bd82c1bc706beae7dc3a350c",
+      "dotted_decimal_identifier": "70567763561641081.489844270461035.258281553147148",
+      "source": "#{local_cookbook_path}",
+      "cache_key": null,
+      "scm_info": null,
+      "source_options": {
+        "path": "#{local_cookbook_path}"
+      }
+    }
+  },
+  "solution_dependencies": {
+    "Policyfile": [
+      [
+        "local-cookbook",
+        ">= 0.0.0"
+      ]
+    ],
+    "dependencies": {
+      "local-cookbook (2.3.4)": [
+
+      ]
+    }
+  }
+}
+E
+      end
+
+      it "reads the lockfile data" do
+        lock = export_service.policyfile_lock
+        expect(lock).to be_an_instance_of(ChefDK::PolicyfileLock)
+        expect(lock.name).to eq("install-example")
+        expect(lock.cookbook_locks.size).to eq(1)
+        expect(lock.cookbook_locks).to have_key("local-cookbook")
+      end
+
+      it "delegates #policy_name to the lockfile" do
+        expect(export_service.policy_name).to eq("install-example")
+      end
+
+      describe "writing updates to the policyfile lock" do
+
+        let(:updated_lockfile_io) { StringIO.new }
+
+        it "validates the lockfile and writes updates to disk" do
+          allow(File).to receive(:open).and_call_original
+          expect(File).to receive(:open).with(policyfile_lock_path, "wb+").and_yield(updated_lockfile_io)
+
+          export_service.run
+        end
+
+      end
+
+      context "copying the cookbooks to the export dir" do
+
+        context "when the export dir is empty" do
+          before do
+            allow(export_service.policyfile_lock).to receive(:validate_cookbooks!).and_return(true)
+            export_service.run
+          end
+
+          let(:cookbook_files) do
+            base_pathname = Pathname.new(local_cookbook_path)
+            Dir.glob("#{local_cookbook_path}/**/*").map do |full_path|
+              Pathname.new(full_path).relative_path_from(base_pathname)
+            end
+          end
+
+          let(:expected_files_relative) do
+            metadata_rb = Pathname.new("metadata.rb")
+            expected = cookbook_files.delete_if { |p| p == metadata_rb }
+            expected << Pathname.new("metadata.json")
+          end
+
+          let(:cookbook_with_version) { "local-cookbook-70567763561641081.489844270461035.258281553147148" }
+
+          let(:exported_cookbook_root) { Pathname.new(File.join(export_dir, "cookbooks", cookbook_with_version)) }
+
+          let(:expected_files) do
+            expected_files_relative.map do |file_rel_path|
+              exported_cookbook_root + file_rel_path
+            end
+          end
+
+          it "copies cookbooks to the target dir in versioned_cookbooks format" do
+            expected_files.each do |expected_file|
+              expect(expected_file).to exist
+            end
+          end
+
+          # This behavior does two things:
+          # * ensures that Chef Zero uses our hacked version number
+          # * works around external dependencies (e.g., using `git` in backticks)
+          #   in metadata.rb issue
+          it "writes metadata.json in the exported cookbook, removing metadata.rb" do
+            metadata_json_path = File.join(exported_cookbook_root, "metadata.json")
+            metadata_json = FFI_Yajl::Parser.parse(IO.read(metadata_json_path))
+            expect(metadata_json["version"]).to eq("70567763561641081.489844270461035.258281553147148")
+          end
+
+          it "copies the policyfile lock in data item format to data_bags/policyfiles" do
+            data_bag_item_path = File.join(export_dir, "data_bags", "policyfiles", "install-example-local.json")
+            data_item_json = FFI_Yajl::Parser.parse(IO.read(data_bag_item_path))
+            expect(data_item_json["id"]).to eq("install-example-local")
+          end
+
+        end
+
+        context "When an error occurs creating the export" do
+
+          before do
+            allow(export_service.policyfile_lock).to receive(:validate_cookbooks!).and_return(true)
+            expect(export_service).to receive(:create_repo_structure).
+              and_raise(Errno::EACCES.new("Permission denied @ rb_sysopen - /etc/foobarbaz.txt"))
+          end
+
+          it "wraps the error in a custom error class" do
+            message = "Failed to export policy (in #{expanded_policyfile_path}) to #{export_dir}"
+            expect { export_service.run }.to raise_error(ChefDK::PolicyfileExportRepoError, message)
+          end
+
+        end
+
+        context "When the export dir has non-conflicting content" do
+
+          let(:file_in_export_dir) { File.join(export_dir, "some_random_cruft") }
+
+          let(:extra_data_bag_dir) { File.join(export_dir, "data_bags", "extraneous") }
+
+          let(:extra_data_bag_item) { File.join(extra_data_bag_dir, "an_item.json") }
+
+          before do
+            FileUtils.mkdir_p(export_dir)
+            File.open(file_in_export_dir, "wb+") { |f| f.print "some random cruft" }
+            FileUtils.mkdir_p(extra_data_bag_dir)
+            File.open(extra_data_bag_item, "wb+") { |f| f.print "some random cruft" }
+          end
+
+          it "ignores the non-conflicting content and exports" do
+            export_service.run
+
+            expect(File).to exist(file_in_export_dir)
+            expect(File).to exist(extra_data_bag_item)
+
+            expect(File).to be_directory(File.join(export_dir, "cookbooks"))
+            expect(File).to be_directory(File.join(export_dir, "data_bags"))
+          end
+        end
+
+        context "When the export dir has conflicting content" do
+
+          let(:non_conflicting_file_in_export_dir) { File.join(export_dir, "some_random_cruft") }
+
+          let(:cookbooks_dir) { File.join(export_dir, "cookbooks") }
+
+          let(:file_in_cookbooks_dir) { File.join(cookbooks_dir, "some_random_cruft") }
+
+          let(:policyfiles_data_bag_dir) { File.join(export_dir, "data_bags", "policyfiles") }
+
+          let(:extra_policyfile_data_item) { File.join(policyfiles_data_bag_dir, "leftover-policy.json") }
+
+          before do
+            FileUtils.mkdir_p(export_dir)
+            FileUtils.mkdir_p(cookbooks_dir)
+            FileUtils.mkdir_p(policyfiles_data_bag_dir)
+            File.open(non_conflicting_file_in_export_dir, "wb+") { |f| f.print "some random cruft" }
+            File.open(file_in_cookbooks_dir, "wb+") { |f| f.print "some random cruft" }
+            File.open(extra_policyfile_data_item, "wb+") { |f| f.print "some random cruft" }
+          end
+
+          it "raises a PolicyfileExportRepoError" do
+            message = "Export dir (#{export_dir}) not clean. Refusing to export. (Conflicting files: #{file_in_cookbooks_dir}, #{extra_policyfile_data_item})"
+            expect { export_service.run }.to raise_error(ChefDK::ExportDirNotEmpty, message)
+            expect(File).to exist(non_conflicting_file_in_export_dir)
+            expect(File).to exist(file_in_cookbooks_dir)
+            expect(File).to exist(extra_policyfile_data_item)
+          end
+
+          context "and the force option is set" do
+
+            let(:force_export) { true }
+
+            it "clears the export dir and exports" do
+              export_service.run
+
+              expect(File).to_not exist(file_in_cookbooks_dir)
+              expect(File).to_not exist(extra_policyfile_data_item)
+
+              expect(File).to exist(non_conflicting_file_in_export_dir)
+
+              expect(File).to be_directory(File.join(export_dir, "cookbooks"))
+              expect(File).to be_directory(File.join(export_dir, "data_bags"))
+            end
+
+          end
+
+        end
+
+      end
+    end
+
+  end
+
+
+
+end
+