chef-dk 0.6.2 → 0.7.0

data/spec/unit/policyfile_services/export_repo_spec.rb

@@ -40,10 +40,13 @@ describe ChefDK::PolicyfileServices::ExportRepo do
 
   let(:force_export) { false }
 
+  let(:archive) { false }
+
   subject(:export_service) do
     described_class.new(policyfile: policyfile_rb_explicit_name,
                         root_dir: working_dir,
                         export_dir: export_dir,
+                        archive: archive,
                         force: force_export)
   end
 
@@ -154,6 +157,22 @@ E
         expect(export_service.policy_name).to eq("install-example")
       end
 
+      context "when using archive mode" do
+
+        let(:archive) { true }
+
+        # TODO: also support a full file name
+        context "when the given 'export_dir' is a directory" do
+
+          it "sets the archive file location to $policy_name-$revision.tgz" do
+            expected = File.join(export_dir, "install-example-60e5ad638dce219d8f87d589463ec4a9884007ba5e2adbb4c0a7021d67204f1a.tgz")
+            expect(export_service.archive_file_location).to eq(expected)
+          end
+
+        end
+
+      end
+
       describe "writing updates to the policyfile lock" do
 
         let(:updated_lockfile_io) { StringIO.new }
@@ -169,7 +188,7 @@ E
 
       context "copying the cookbooks to the export dir" do
 
-        context "when the export dir is empty" do
+        shared_examples_for "successful_export" do
           before do
             allow(export_service.policyfile_lock).to receive(:validate_cookbooks!).and_return(true)
             export_service.run
@@ -220,6 +239,23 @@ E
             expect(data_item_json["id"]).to eq("install-example-local")
           end
 
+          it "copies the policyfile lock in standard format to Policyfile.lock.json" do
+            policyfile_lock_path = File.join(export_dir, "Policyfile.lock.json")
+            policyfile_lock_data = FFI_Yajl::Parser.parse(IO.read(policyfile_lock_path))
+            expected_lock_data = export_service.policyfile_lock.to_lock
+
+            # stringify keys in source_options
+            path = expected_lock_data["cookbook_locks"]["local-cookbook"]["source_options"].delete(:path)
+            expected_lock_data["cookbook_locks"]["local-cookbook"]["source_options"]["path"] = path
+
+            expect(policyfile_lock_data).to eq(expected_lock_data)
+          end
+
+        end
+
+        context "when the export dir is empty" do
+
+          include_examples "successful_export"
         end
 
         context "When an error occurs creating the export" do
@@ -253,14 +289,15 @@ E
           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
+
+          include_examples "successful_export"
+
         end
 
         context "When the export dir has conflicting content" do
@@ -275,6 +312,8 @@ E
 
           let(:extra_policyfile_data_item) { File.join(policyfiles_data_bag_dir, "leftover-policy.json") }
 
+          let(:conflicting_policyfile_lock) { File.join(export_dir, "Policyfile.lock.json") }
+
           before do
             FileUtils.mkdir_p(export_dir)
             FileUtils.mkdir_p(cookbooks_dir)
@@ -282,10 +321,11 @@ E
             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" }
+            File.open(conflicting_policyfile_lock, "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})"
+            message = "Export dir (#{export_dir}) not clean. Refusing to export. (Conflicting files: #{file_in_cookbooks_dir}, #{extra_policyfile_data_item}, #{conflicting_policyfile_lock})"
             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)
@@ -310,9 +350,62 @@ E
 
           end
 
-        end
+        end # When the export dir has conflicting content
 
-      end
+        context "when archive mode is enabled" do
+
+          let(:archive) { true }
+
+          let(:expected_archive_path) do
+            File.join(export_dir, "install-example-60e5ad638dce219d8f87d589463ec4a9884007ba5e2adbb4c0a7021d67204f1a.tgz")
+          end
+
+          it "exports the repo as a tgz archive" do
+            expect(File).to exist(expected_archive_path)
+          end
+
+          include_examples "successful_export" do
+
+            # explode the tarball so the assertions can find the files
+            before do
+              Zlib::GzipReader.open(expected_archive_path) do |gz_file|
+                tar = Archive::Tar::Minitar::Input.new(gz_file)
+                tar.each do |e|
+                  tar.extract_entry(export_dir, e)
+                end
+              end
+            end
+
+          end
+
+          context "when the target dir has a cookbooks or data_bags dir" do
+
+            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(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 "exports successfully" do
+              expect { export_service.run }.to_not raise_error
+              expect(File).to exist(expected_archive_path)
+            end
+
+          end
+
+        end # when archive mode is enabled
+
+      end # copying the cookbooks to the export dir
     end
 
   end

data/spec/unit/policyfile_services/push_archive_spec.rb

@@ -0,0 +1,345 @@
+#
+# 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-dk/policyfile_services/push_archive'
+
+describe ChefDK::PolicyfileServices::PushArchive do
+
+  FileToTar = Struct.new(:name, :content)
+
+  def create_archive
+    Zlib::GzipWriter.open(archive_file_path) do |gz_file|
+      Archive::Tar::Minitar::Writer.open(gz_file) do |tar|
+
+
+        archive_dirs.each do |dir|
+          tar.mkdir(dir, mode: 0755)
+        end
+
+        archive_files.each do |file|
+          name = file.name
+          content = file.content
+          size = content.bytesize
+          tar.add_file_simple(name, mode: 0644, size: size) { |f| f.write(content) }
+        end
+
+      end
+    end
+  end
+
+  let(:valid_lockfile) 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": "project-cookbooks/local-cookbook",
+      "cache_key": null,
+      "scm_info": null,
+      "source_options": {
+        "path": "project-cookbooks/local-cookbook"
+      }
+    }
+  },
+  "default_attributes": {},
+  "override_attributes": {},
+  "solution_dependencies": {
+    "Policyfile": [
+      [
+        "local-cookbook",
+        ">= 0.0.0"
+      ]
+    ],
+    "dependencies": {
+      "local-cookbook (2.3.4)": [
+
+      ]
+    }
+  }
+}
+E
+  end
+
+  let(:archive_files) { [] }
+
+  let(:archive_dirs) { [] }
+
+  let(:working_dir) do
+    path = File.join(tempdir, "policyfile_services_test_working_dir")
+    Dir.mkdir(path)
+    path
+  end
+
+  let(:archive_file_name) { "example-policy-abc123.tgz" }
+
+  let(:archive_file_path) { File.join(working_dir, archive_file_name) }
+
+  let(:policy_group) { "dev-cluster-1" }
+
+  let(:config) do
+    double("Chef::Config",
+           chef_server_url: "https://localhost:10443",
+           client_key: "/path/to/client/key.pem",
+           node_name: "deuce",
+           policy_document_native_api: true)
+  end
+
+  let(:ui) { TestHelpers::TestUI.new }
+
+  subject(:push_archive_service) do
+    described_class.new(archive_file: archive_file_name,
+                        policy_group: policy_group,
+                        root_dir: working_dir,
+                        ui: ui,
+                        config: config)
+  end
+
+  it "has an archive file" do
+    expect(push_archive_service.archive_file).to eq(archive_file_name)
+    expect(push_archive_service.archive_file_path).to eq(archive_file_path)
+  end
+
+  it "configures an HTTP client" do
+    expect(ChefDK::AuthenticatedHTTP).to receive(:new).with("https://localhost:10443",
+                                                       signing_key_filename: "/path/to/client/key.pem",
+                                                       client_name: "deuce")
+    push_archive_service.http_client
+  end
+
+  context "with an invalid archive" do
+
+    let(:exception) do
+      begin
+        push_archive_service.run
+      rescue ChefDK::PolicyfilePushArchiveError => e
+        e
+      else
+        nil
+      end
+    end
+
+    let(:exception_cause) { exception.cause }
+
+    context "when the archive is malformed/corrupted/etc" do
+
+      context "when the archive file doesn't exist" do
+
+        it "errors out" do
+          expect(exception).to_not be_nil
+          expect(exception.message).to eq("Failed to publish archived policy")
+          expect(exception_cause).to be_a(ChefDK::InvalidPolicyArchive)
+          expect(exception_cause.message).to eq("Archive file #{archive_file_path} not found")
+        end
+      end
+
+      context "when the archive is not a gzip file" do
+
+        before do
+          FileUtils.touch(archive_file_path)
+        end
+
+        it "errors out" do
+          expect(exception).to_not be_nil
+          expect(exception.message).to eq("Failed to publish archived policy")
+          expect(exception_cause).to be_a(ChefDK::InvalidPolicyArchive)
+          expect(exception_cause.message).to eq("Archive file #{archive_file_path} could not be unpacked. not in gzip format")
+        end
+
+      end
+
+      context "when the archive is a gzip file of a garbage file" do
+
+        before do
+          Zlib::GzipWriter.open(archive_file_path) do |gz_file|
+            gz_file << "lol this isn't a tar file"
+          end
+        end
+
+        it "errors out" do
+          expect(exception).to_not be_nil
+          expect(exception.message).to eq("Failed to publish archived policy")
+          expect(exception_cause).to be_a(ChefDK::InvalidPolicyArchive)
+          expect(exception_cause.message).to eq("Archive file #{archive_file_path} could not be unpacked. Tar archive looks corrupt.")
+        end
+      end
+
+
+      context "when the archive is a gzip file of a very malformed tar archive" do
+
+        before do
+          Zlib::GzipWriter.open(archive_file_path) do |gz_file|
+            gz_file << "\0\0\0\0\0"
+          end
+        end
+
+        it "errors out" do
+          expect(exception).to_not be_nil
+          expect(exception.message).to eq("Failed to publish archived policy")
+          expect(exception_cause).to be_a(ChefDK::InvalidPolicyArchive)
+          expect(exception_cause.message).to eq("Archive file #{archive_file_path} could not be unpacked. Tar archive looks corrupt.")
+        end
+      end
+    end
+
+    context "when the archive is well-formed but has invalid content" do
+
+      before do
+        create_archive
+      end
+
+      context "when the archive is missing Policyfile.lock.json" do
+
+        let(:archive_files) { [ FileToTar.new("empty.txt", "") ] }
+
+        it "errors out" do
+          expect(exception).to_not be_nil
+          expect(exception.message).to eq("Failed to publish archived policy")
+          expect(exception_cause).to be_a(ChefDK::InvalidPolicyArchive)
+          expect(exception_cause.message).to eq("Archive does not contain a Policyfile.lock.json")
+        end
+
+      end
+
+      context "when the archive has no cookbooks/ directory" do
+
+        let(:archive_files) { [ FileToTar.new("Policyfile.lock.json", "") ] }
+
+        it "errors out" do
+          expect(exception).to_not be_nil
+          expect(exception.message).to eq("Failed to publish archived policy")
+          expect(exception_cause).to be_a(ChefDK::InvalidPolicyArchive)
+          expect(exception_cause.message).to eq("Archive does not contain a cookbooks directory")
+        end
+
+      end
+
+      context "when the archive has the correct files but the lockfile is invalid" do
+
+        let(:archive_dirs) { ["cookbooks"] }
+
+        let(:archive_files) { [ FileToTar.new("Policyfile.lock.json", lockfile_content) ] }
+
+        context "when the lockfile has invalid JSON" do
+
+          let(:lockfile_content) { ":::" }
+
+          it "errors out" do
+            expect(exception).to_not be_nil
+            expect(exception.message).to eq("Failed to publish archived policy")
+            expect(exception_cause).to be_a(FFI_Yajl::ParseError)
+          end
+
+        end
+
+        context "when the lockfile is semantically invalid" do
+
+          let(:lockfile_content) { '{ }' }
+
+          it "errors out" do
+            expect(exception).to_not be_nil
+            expect(exception.message).to eq("Failed to publish archived policy")
+            expect(exception_cause).to be_a(ChefDK::InvalidLockfile)
+          end
+
+        end
+
+
+        context "when the archive does not have all the necessary cookbooks" do
+
+          let(:lockfile_content) { valid_lockfile }
+
+          it "errors out" do
+            expect(exception).to_not be_nil
+            expect(exception.message).to eq("Failed to publish archived policy")
+            expect(exception_cause).to be_a(ChefDK::InvalidPolicyArchive)
+
+            msg = "Archive does not have all cookbooks required by the Policyfile.lock. Missing cookbooks: 'local-cookbook'."
+            expect(exception_cause.message).to eq(msg)
+          end
+
+        end
+      end
+    end
+
+  end
+
+  context "with a valid archive" do
+
+    let(:lockfile_content) { valid_lockfile }
+
+    let(:cookbook_name) { "local-cookbook" }
+
+    let(:dotted_decimal_identifier) { "70567763561641081.489844270461035.258281553147148" }
+
+    let(:cookbook_dir) { File.join("cookbooks", "#{cookbook_name}-#{dotted_decimal_identifier}") }
+
+    let(:recipes_dir) { File.join(cookbook_dir, "recipes") }
+
+    let(:archive_dirs) { ["cookbooks", cookbook_dir, recipes_dir] }
+
+    let(:archive_files) do
+      [
+        FileToTar.new("Policyfile.lock.json", lockfile_content),
+        FileToTar.new(File.join(cookbook_dir, "metadata.rb"), "name 'local-cookbook'"),
+        FileToTar.new(File.join(recipes_dir, "default.rb"), "puts 'hello'")
+      ]
+    end
+
+    let(:http_client) { instance_double(ChefDK::AuthenticatedHTTP) }
+
+    let(:uploader) { instance_double(ChefDK::Policyfile::Uploader) }
+
+    before do
+      expect(push_archive_service).to receive(:http_client).and_return(http_client)
+
+      expect(ChefDK::Policyfile::Uploader).to receive(:new).
+        # TODO: need more verification that the policyfile.lock is right (?)
+        with(an_instance_of(ChefDK::PolicyfileLock), policy_group, http_client: http_client, ui: ui, policy_document_native_api: true).
+        and_return(uploader)
+
+      create_archive
+    end
+
+    describe "when the upload is successful" do
+
+      it "uploads the cookbooks and lockfile" do
+        expect(uploader).to receive(:upload)
+        push_archive_service.run
+      end
+
+    end
+
+    describe "when the upload fails" do
+
+      it "raises a nested error" do
+        expect(uploader).to receive(:upload).and_raise("an error")
+        expect { push_archive_service.run }.to raise_error(ChefDK::PolicyfilePushArchiveError)
+      end
+
+    end
+
+  end
+
+end
+