chef-cli 1.0.3

data/spec/unit/policyfile_services/undelete_spec.rb

@@ -0,0 +1,302 @@
+#
+# 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_services/undelete"
+
+describe ChefCLI::PolicyfileServices::Undelete do
+
+  let(:chef_config) { double("Chef::Config") }
+
+  let(:ui) { TestHelpers::TestUI.new }
+
+  let(:policy_name) { nil }
+
+  let(:policy_group) { nil }
+
+  let(:show_orphans) { false }
+
+  let(:summary_diff) { false }
+
+  let(:undo_dir) { tempdir }
+
+  let(:undo_record_id) { nil }
+
+  subject(:undelete_service) do
+    described_class.new(config: chef_config,
+                        ui: ui,
+                        undo_record_id: undo_record_id)
+  end
+
+  describe "listing undo operations" do
+
+    before do
+      allow(undelete_service.undo_stack).to receive(:undo_dir).and_return(undo_dir)
+    end
+
+    after do
+      clear_tempdir
+    end
+
+    context "when the undo dir doesn't exist" do
+
+      let(:undo_dir) { File.join(tempdir, "this", "isnt", "here") }
+
+      it "prints a message saying there aren't any things to undo to stderr" do
+        undelete_service.list
+        expect(ui.output).to eq("Nothing to undo.\n")
+      end
+
+    end
+
+    context "when the undo dir exists, but it empty" do
+
+      it "prints a message saying there aren't any things to undo to stderr" do
+        undelete_service.list
+        expect(ui.output).to eq("Nothing to undo.\n")
+      end
+
+    end
+
+    context "when the undo dir exists and there are undo records in it" do
+
+      let(:policy_revision) do
+        {
+          "name" => "appserver",
+          "revision_id" => "1111111111111111111111111111111111111111111111111111111111111111",
+        }
+      end
+
+      let(:undo_record1) do
+        ChefCLI::Policyfile::UndoRecord.new.tap do |undo_record|
+          undo_record.description = "delete-policy-group example1"
+          undo_record.add_policy_group("example1")
+          undo_record.add_policy_revision("appserver", "example1", policy_revision)
+        end
+      end
+
+      let(:undo_record2) do
+        ChefCLI::Policyfile::UndoRecord.new.tap do |undo_record|
+          undo_record.description = "delete-policy-group example2"
+          undo_record.add_policy_group("example2")
+          undo_record.add_policy_revision("appserver", "example2", policy_revision)
+        end
+      end
+
+      let(:undo_record3) do
+        ChefCLI::Policyfile::UndoRecord.new.tap do |undo_record|
+          undo_record.description = "delete-policy-group example3"
+          undo_record.add_policy_group("example3")
+          undo_record.add_policy_revision("appserver", "example3", policy_revision)
+        end
+      end
+
+      # `Time.new` is stubbed later on, need to force it to be evaluated before
+      # then.
+      let!(:start_time) { Time.new }
+
+      def next_time
+        @increment ||= 0
+        @increment += 1
+
+        start_time + @increment
+      end
+
+      let(:times) { [] }
+
+      before do
+        allow(Time).to receive(:new) do
+          t = next_time
+          times << t
+          t
+        end
+        undo_stack = ChefCLI::Policyfile::UndoStack.new
+        allow(undo_stack).to receive(:undo_dir).and_return(undo_dir)
+        undo_stack.push(undo_record1).push(undo_record2).push(undo_record3)
+      end
+
+      it "prints the items in reverse chronological order" do
+        undelete_service.list
+
+        timestamps = times.map { |t| t.utc.strftime("%Y%m%d%H%M%S") }
+
+        expected_output = <<~OUTPUT
+          #{timestamps[2]}: delete-policy-group example3
+          #{timestamps[1]}: delete-policy-group example2
+          #{timestamps[0]}: delete-policy-group example1
+        OUTPUT
+        expect(ui.output).to eq(expected_output)
+      end
+
+    end
+
+  end
+
+  describe "undoing a policy group delete" do
+
+    let(:policy_revision) do
+      {
+        "name" => "appserver",
+        "revision_id" => "1111111111111111111111111111111111111111111111111111111111111111",
+      }
+    end
+
+    let(:undo_record1) do
+      ChefCLI::Policyfile::UndoRecord.new.tap do |undo_record|
+        undo_record.description = "delete-policy-group example1"
+        undo_record.add_policy_group("example1")
+        undo_record.add_policy_revision("appserver", "example1", policy_revision)
+      end
+    end
+
+    let(:undo_stack) do
+      instance_double(ChefCLI::Policyfile::UndoStack).tap do |s|
+        allow(s).to receive(:pop).and_yield(undo_record1)
+      end
+    end
+
+    let(:http_client) { instance_double(Chef::ServerAPI) }
+
+    before do
+      allow(undelete_service).to receive(:http_client).and_return(http_client)
+      allow(undelete_service).to receive(:undo_stack).and_return(undo_stack)
+    end
+
+    describe "when an error occurs posting data to the server" do
+
+      let(:response) do
+        Net::HTTPResponse.send(:response_class, "500").new("1.0", "500", "Internal Server Error").tap do |r|
+          r.instance_variable_set(:@body, "oops")
+        end
+      end
+
+      let(:http_exception) do
+        begin
+          response.error!
+        rescue => e
+          e
+        end
+      end
+
+      before do
+        expect(http_client).to receive(:put)
+          .with("/policy_groups/example1/policies/appserver", policy_revision)
+          .and_raise(http_exception)
+      end
+
+      it "raises an error" do
+        expect { undelete_service.run }.to raise_error(ChefCLI::UndeleteError)
+      end
+
+    end
+
+    context "when the undelete is successful" do
+
+      before do
+        expect(http_client).to receive(:put)
+          .with("/policy_groups/example1/policies/appserver", policy_revision)
+      end
+
+      it "uploads all policies to the server" do
+        undelete_service.run
+        expect(ui.output).to eq("Restored policy 'appserver'\nRestored policy group 'example1'\n")
+      end
+
+    end
+
+    context "when given a specific undo record id to undo" do
+
+      let(:undo_record_id) { "20150827172127" }
+
+      context "and the id doesn't exist" do
+
+        before do
+          expect(undo_stack).to receive(:has_id?).with(undo_record_id).and_return(false)
+        end
+
+        it "prints an error message that the id doesn't exist" do
+          undelete_service.run
+          expect(ui.output).to eq("No undo record with id '#{undo_record_id}' exists\n")
+        end
+
+      end
+
+      context "and the id exists" do
+        before do
+          expect(undo_stack).to receive(:has_id?).with(undo_record_id).and_return(true)
+          expect(undo_stack).to receive(:delete).with(undo_record_id).and_yield(undo_record1)
+          expect(http_client).to receive(:put)
+            .with("/policy_groups/example1/policies/appserver", policy_revision)
+        end
+
+        it "uploads all policies to the server" do
+          undelete_service.run
+          expect(ui.output).to eq("Restored policy 'appserver'\nRestored policy group 'example1'\n")
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "undoing a policy delete" do
+
+    let(:policy_revision) do
+      {
+        "name" => "appserver",
+        "revision_id" => "1111111111111111111111111111111111111111111111111111111111111111",
+      }
+    end
+
+    let(:undo_record1) do
+      ChefCLI::Policyfile::UndoRecord.new.tap do |undo_record|
+        undo_record.description = "delete-policy-group example1"
+        undo_record.add_policy_revision("appserver", nil, policy_revision)
+      end
+    end
+
+    let(:undo_stack) do
+      instance_double(ChefCLI::Policyfile::UndoStack).tap do |s|
+        allow(s).to receive(:pop).and_yield(undo_record1)
+      end
+    end
+
+    let(:http_client) { instance_double(Chef::ServerAPI) }
+
+    before do
+      allow(undelete_service).to receive(:http_client).and_return(http_client)
+      allow(undelete_service).to receive(:undo_stack).and_return(undo_stack)
+    end
+
+    context "when the revision to create doesn't exist" do
+
+      before do
+        expect(http_client).to receive(:post)
+          .with("/policies/appserver/revisions", policy_revision)
+      end
+
+      it "uploads all policies to the server" do
+        undelete_service.run
+        expect(ui.output).to eq("Restored policy 'appserver'\n")
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/policyfile_services/update_attributes_spec.rb

@@ -0,0 +1,229 @@
+#
+# 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/helpers"
+require "chef-cli/policyfile_services/update_attributes"
+
+describe ChefCLI::PolicyfileServices::UpdateAttributes do
+
+  include ChefCLI::Helpers
+
+  let(:working_dir) do
+    path = File.join(tempdir, "policyfile_services_test_working_dir")
+    Dir.mkdir(path)
+    path
+  end
+
+  let(:policyfile_rb_explicit_name) { nil }
+
+  let(:policyfile_rb_name) { policyfile_rb_explicit_name || "Policyfile.rb" }
+
+  let(:policyfile_lock_name) { "Policyfile.lock.json" }
+
+  let(:policyfile_rb_path) { File.join(working_dir, policyfile_rb_name) }
+
+  let(:policyfile_lock_path) { File.join(working_dir, policyfile_lock_name) }
+
+  let(:local_cookbooks_root) do
+    File.join(fixtures_path, "local_path_cookbooks")
+  end
+
+  let(:local_cookbook_path) { File.join(local_cookbooks_root, "local-cookbook") }
+
+  let(:local_cookbook_copy_path) { File.join(working_dir, "cookbooks/local-cookbook") }
+
+  let(:policyfile_content) do
+    <<~E
+      name 'install-example'
+
+      run_list 'local-cookbook'
+
+      cookbook 'local-cookbook', path: 'cookbooks/local-cookbook'
+
+      default["default_attr"] = "new_value_default"
+
+      override["override_attr"] = "new_value_override"
+    E
+  end
+
+  let(:ui) { TestHelpers::TestUI.new }
+
+  let(:storage_config) do
+    ChefCLI::Policyfile::StorageConfig.new( cache_path: nil, relative_paths_root: working_dir )
+  end
+
+  subject(:update_attrs_service) { described_class.new(policyfile: policyfile_rb_name, ui: ui, root_dir: working_dir) }
+
+  before do
+    FileUtils.mkdir_p(File.dirname(local_cookbook_copy_path))
+    FileUtils.cp_r(local_cookbook_path, local_cookbook_copy_path)
+  end
+
+  context "when first created" do
+
+    it "has the UI object it was created with" do
+      expect(update_attrs_service.ui).to eq(ui)
+    end
+
+    it "creates a storage config from the given policyfile path and root dir" do
+      new_storage_config = instance_double("ChefCLI::Policyfile::StorageConfig")
+      expect(ChefCLI::Policyfile::StorageConfig).to receive(:new).with(no_args).and_return(new_storage_config)
+      expect(new_storage_config).to receive(:use_policyfile).with(policyfile_rb_path).and_return(new_storage_config)
+      expect(update_attrs_service.storage_config).to eq(new_storage_config)
+    end
+
+  end
+
+  context "when no Policyfile is present or specified" do
+
+    it "errors out" do
+      expect { update_attrs_service.assert_policy_and_lock_present! }.to raise_error(ChefCLI::PolicyfileNotFound, "Policyfile not found at path #{policyfile_rb_path}")
+      expect { update_attrs_service.run }.to raise_error(ChefCLI::PolicyfileUpdateError)
+    end
+
+  end
+
+  context "when no lockfile exists" do
+
+    it "errors out" do
+      with_file(policyfile_rb_path) { |f| f.print(policyfile_content) }
+      expect { update_attrs_service.assert_policy_and_lock_present! }.to raise_error(ChefCLI::LockfileNotFound, "Policyfile lock not found at path #{policyfile_lock_path}")
+      expect { update_attrs_service.run }.to raise_error(ChefCLI::PolicyfileUpdateError)
+    end
+
+  end
+
+  context "when both the policyfile and lockfile exist" do
+
+    let(:lock_data_with_new_values) do
+      {
+        "revision_id" => "522d740beba4c4e5857bd8bccdb2d7ffd0bbd45ac4350f92b26e4e3b8f68d530",
+        "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" => "cookbooks/local-cookbook",
+            "cache_key" => nil,
+            "scm_info" => nil,
+            "source_options" => {
+              "path" => "cookbooks/local-cookbook",
+            },
+          },
+        },
+        "default_attributes" => { "default_attr" => "new_value_default" },
+        "override_attributes" => { "override_attr" => "new_value_override" },
+        "solution_dependencies" => {
+          "Policyfile" => [["local-cookbook", ">= 0.0.0"]],
+          "dependencies" => { "local-cookbook (2.3.4)" => [] },
+        },
+        "included_policy_locks" => [],
+      }
+    end
+
+    let(:previous_policyfile_lock_data) { lock_data_with_new_values }
+
+    let(:policyfile_lock_content) do
+      FFI_Yajl::Encoder.encode(previous_policyfile_lock_data, pretty: true )
+    end
+
+    before do
+      with_file(policyfile_rb_path) { |f| f.print(policyfile_content) }
+      with_file(policyfile_lock_path) { |f| f.print(policyfile_lock_content) }
+    end
+
+    def result_policyfile_lock_data
+      expect(File).to exist(policyfile_lock_path)
+      content = IO.read(policyfile_lock_path)
+      FFI_Yajl::Parser.parse(content)
+    end
+
+    context "when the current lock already has the desired attributes" do
+
+      it "makes no changes to the lockfile" do
+        update_attrs_service.run
+        expect(result_policyfile_lock_data).to eq(lock_data_with_new_values)
+      end
+
+      it "emits a message that no changes have been made to the lockfile" do
+        update_attrs_service.run
+
+        message = "Attributes already up to date"
+        expect(ui.output).to include(message)
+      end
+
+      context "when a policyfile is included" do
+        let(:lock_applier) { instance_double("ChefCLI::Policyfile::LockApplier") }
+
+        it "locks the included policyfile" do
+          expect(ChefCLI::Policyfile::LockApplier).to receive(:new).with(
+            update_attrs_service.policyfile_lock, update_attrs_service.policyfile_compiler).and_return(lock_applier)
+          expect(lock_applier).not_to receive(:with_unlocked_policies)
+          expect(lock_applier).to receive(:apply!)
+
+          update_attrs_service.run
+        end
+      end
+    end
+
+    context "when the Policyfile.rb has different attributes than the lockfile" do
+
+      let(:previous_policyfile_lock_data) do
+        {
+          "revision_id" => "522d740beba4c4e5857bd8bccdb2d7ffd0bbd45ac4350f92b26e4e3b8f68d530",
+          "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" => "cookbooks/local-cookbook",
+              "cache_key" => nil,
+              "scm_info" => nil,
+              "source_options" => {
+                "path" => "cookbooks/local-cookbook",
+              },
+            },
+          },
+          "default_attributes" => { "default_attr" => "old_value_default" },
+          "override_attributes" => { "override_attr" => "old_value_override" },
+          "solution_dependencies" => {
+            "Policyfile" => [["local-cookbook", ">= 0.0.0"]],
+            "dependencies" => { "local-cookbook (2.3.4)" => [] },
+          },
+        }
+      end
+
+      it "updates the lockfile with the new attributes" do
+        update_attrs_service.run
+        expect(result_policyfile_lock_data).to eq(lock_data_with_new_values)
+      end
+
+      it "emits a messsage stating the attributes have been updated" do
+        update_attrs_service.run
+        expect(ui.output).to include("Updated attributes in #{policyfile_lock_path}")
+      end
+
+    end
+
+  end
+
+end