chef-dk 0.7.0 → 0.8.0

data/spec/unit/helpers_spec.rb

@@ -64,5 +64,29 @@ describe ChefDK::Helpers do
       end
     end
 
+    context 'using usr_bin_prefix' do
+      before do
+        stub_const('RUBY_PLATFORM', ruby_platform_string)
+      end
+
+      context 'on Mac' do
+        let(:ruby_platform_string) { 'x86_64-darwin12.0' }
+
+        it 'uses /usr/local/bin' do
+          expect(helpers.usr_bin_prefix).to eq('/usr/local/bin')
+          expect(helpers.usr_bin_path('berks')).to eq('/usr/local/bin/berks')
+        end
+      end
+
+      context 'on other systems' do
+        let(:ruby_platform_string) { 'x86_64-linux' }
+
+        it 'uses /usr/bin' do
+          expect(helpers.usr_bin_prefix).to eq('/usr/bin')
+          expect(helpers.usr_bin_path('berks')).to eq('/usr/bin/berks')
+        end
+      end
+    end
+
   end
 end

data/spec/unit/policyfile/lister_spec.rb

@@ -248,6 +248,22 @@ describe ChefDK::Policyfile::Lister do
         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

data/spec/unit/policyfile/undo_record_spec.rb

@@ -0,0 +1,260 @@
+#
+# 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/undo_record'
+
+describe ChefDK::Policyfile::UndoRecord do
+
+  subject(:undo_record) { described_class.new }
+
+  let(:policy_revision) do
+    {
+      "name" => "appserver",
+      "revision_id" => "1111111111111111111111111111111111111111111111111111111111111111"
+    }
+  end
+
+  context "when empty" do
+
+    it "has an empty description" do
+      expect(undo_record.description).to eq("")
+    end
+
+    it "has an empty set of policy groups" do
+      expect(undo_record.policy_groups).to eq([])
+    end
+
+    it "has an empty set of policy revisions" do
+      expect(undo_record.policy_revisions).to eq([])
+    end
+
+    it "converts to a serializable data structure" do
+      expected = {
+        "format_version" => 1,
+        "description" => "",
+        "backup_data" => {
+          "policy_groups" => [],
+          "policy_revisions" => []
+        }
+      }
+      expect(undo_record.for_serialization).to eq(expected)
+    end
+  end
+
+  context "with policy data" do
+
+    before do
+      undo_record.description = "delete-policy-group preprod"
+      undo_record.add_policy_group("preprod")
+      undo_record.add_policy_revision("appserver", "preprod", policy_revision)
+    end
+
+    it "has a description" do
+      expect(undo_record.description).to eq("delete-policy-group preprod")
+    end
+
+    it "has a policy group" do
+      expect(undo_record.policy_groups).to eq( [ "preprod" ] )
+    end
+
+    it "has a policy revision" do
+      expect(undo_record.policy_revisions.size).to eq(1)
+      revision_info = undo_record.policy_revisions.first
+      expect(revision_info.policy_name).to eq("appserver")
+      expect(revision_info.policy_group).to eq("preprod")
+      expect(revision_info.data).to eq(policy_revision)
+    end
+
+    it "converts to a serializable data structure" do
+      expected = {
+        "format_version" => 1,
+        "description" => "delete-policy-group preprod",
+        "backup_data" => {
+          "policy_groups" => [ "preprod" ],
+          "policy_revisions" => [
+            {
+              "policy_name" => "appserver",
+              "policy_group" => "preprod",
+              "data" => policy_revision
+            }
+          ]
+        }
+      }
+      expect(undo_record.for_serialization).to eq(expected)
+    end
+
+  end
+
+  describe "loading from serialized data" do
+
+    context "with invalid data" do
+
+      context "with an invalid object type" do
+
+        let(:serialized_data) { [] }
+
+        it "raises an error" do
+          expect { undo_record.load(serialized_data) }.to raise_error(ChefDK::InvalidUndoRecord)
+        end
+
+      end
+
+      context "when required top-level keys aren't present" do
+
+        let(:serialized_data) { {} }
+
+        it "raises an error" do
+          expect { undo_record.load(serialized_data) }.to raise_error(ChefDK::InvalidUndoRecord)
+        end
+
+      end
+
+      context "when backup_data is an invalid type" do
+
+        let(:serialized_data) do
+          {
+            "format_version" => 1,
+            "description" => "delete-policy-group preprod",
+            "backup_data" => []
+          }
+        end
+
+        it "raises an error" do
+          expect { undo_record.load(serialized_data) }.to raise_error(ChefDK::InvalidUndoRecord)
+        end
+
+      end
+
+      context "when backup_data is missing required fields" do
+
+        let(:serialized_data) do
+          {
+            "format_version" => 1,
+            "description" => "delete-policy-group preprod",
+            "backup_data" => {}
+          }
+        end
+
+        it "raises an error" do
+          expect { undo_record.load(serialized_data) }.to raise_error(ChefDK::InvalidUndoRecord)
+        end
+
+      end
+
+      context "when backup_data has invalid policy_groups data" do
+
+        let(:serialized_data) do
+          {
+            "format_version" => 1,
+            "description" => "delete-policy-group preprod",
+            "backup_data" => {
+              "policy_groups" => nil,
+              "policy_revisions" => []
+            }
+          }
+        end
+
+        it "raises an error" do
+          expect { undo_record.load(serialized_data) }.to raise_error(ChefDK::InvalidUndoRecord)
+        end
+
+      end
+
+      context "when backup_data has and invalid type for policy_revisions" do
+
+        let(:serialized_data) do
+          {
+            "format_version" => 1,
+            "description" => "delete-policy-group preprod",
+            "backup_data" => {
+              "policy_groups" => [],
+              "policy_revisions" => nil
+            }
+          }
+        end
+
+        it "raises an error" do
+          expect { undo_record.load(serialized_data) }.to raise_error(ChefDK::InvalidUndoRecord)
+        end
+
+      end
+
+      context "when the backup_data has an invalid item in policy revisions" do
+
+        let(:serialized_data) do
+          {
+            "format_version" => 1,
+            "description" => "delete-policy-group preprod",
+            "backup_data" => {
+              "policy_groups" => [],
+              "policy_revisions" => [ nil ]
+            }
+          }
+        end
+
+        it "raises an error" do
+          expect { undo_record.load(serialized_data) }.to raise_error(ChefDK::InvalidUndoRecord)
+        end
+
+      end
+    end
+
+    context "with valid data" do
+      let(:serialized_data) do
+        {
+          "format_version" => 1,
+          "description" => "delete-policy-group preprod",
+          "backup_data" => {
+            "policy_groups" => [ "preprod" ],
+            "policy_revisions" => [
+              {
+                "policy_name" => "appserver",
+                "policy_group" => "preprod",
+                "data" => policy_revision
+              }
+            ]
+          }
+        }
+      end
+
+      before do
+        undo_record.load(serialized_data)
+      end
+
+      it "has a policy group" do
+        expect(undo_record.policy_groups).to eq( [ "preprod" ] )
+      end
+
+      it "has a policy revision" do
+        expect(undo_record.policy_revisions.size).to eq(1)
+        revision_info = undo_record.policy_revisions.first
+        expect(revision_info.policy_name).to eq("appserver")
+        expect(revision_info.policy_group).to eq("preprod")
+        expect(revision_info.data).to eq(policy_revision)
+      end
+
+      it "converts to a serializable data structure" do
+        expect(undo_record.for_serialization).to eq(serialized_data)
+      end
+
+
+    end
+  end
+
+end
+

data/spec/unit/policyfile/undo_stack_spec.rb

@@ -0,0 +1,266 @@
+#
+# 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/undo_stack'
+
+describe ChefDK::Policyfile::UndoStack do
+
+  let(:chefdk_home) { File.join(tempdir, "chefdk_home", ".chefdk") }
+
+  let(:policy_revision) do
+    {
+      "name" => "appserver",
+      "revision_id" => "1111111111111111111111111111111111111111111111111111111111111111"
+    }
+  end
+
+  let(:undo_record) do
+    ChefDK::Policyfile::UndoRecord.new.tap do |undo_record|
+      undo_record.add_policy_group("preprod")
+      undo_record.add_policy_revision("appserver", "preprod", policy_revision)
+    end
+  end
+
+  # Probably takes a Chef::Config as an arg?
+  subject(:undo_stack) { described_class.new }
+
+  let(:expected_undo_dir) { File.join(chefdk_home, "undo") }
+
+  def undo_stack_files
+    Dir[File.join(expected_undo_dir, "*")]
+  end
+
+  before do
+    clear_tempdir
+    allow(ChefDK::Helpers).to receive(:chefdk_home).and_return(chefdk_home)
+  end
+
+  after(:all) do
+    clear_tempdir
+  end
+
+  it "uses chefdk_home to infer the location of the undo directory" do
+    expect(undo_stack.undo_dir).to eq(expected_undo_dir)
+  end
+
+  context "when there are no undo records" do
+
+    it "has zero items" do
+      expect(undo_stack.size).to eq(0)
+    end
+
+    it "is empty" do
+      expect(undo_stack).to be_empty
+    end
+
+    it "has no items to iterate over" do
+      expect { |b| undo_stack.each_with_id(&b) }.to_not yield_control
+    end
+
+    it "has an empty list of undo records" do
+      expect(undo_stack.undo_records).to eq([])
+    end
+
+    it "raises an error when attempting to pop an item from the stack" do
+      expect { undo_stack.pop }.to raise_error(ChefDK::CantUndo)
+    end
+
+    describe "pushing an undo record" do
+
+      before do
+        expect(File.exist?(chefdk_home)).to be(false)
+        expect(File.exist?(expected_undo_dir)).to be(false)
+
+        undo_stack.push(undo_record)
+      end
+
+      it "creates the undo directory" do
+        expect(File.exist?(chefdk_home)).to be(true)
+        expect(File.exist?(expected_undo_dir)).to be(true)
+      end
+
+      it "creates the undo record" do
+        expect(undo_stack_files.size).to eq(1)
+
+        undo_record_json = IO.read(undo_stack_files.first)
+        undo_record_data = FFI_Yajl::Parser.parse(undo_record_json)
+        expect(undo_record_data).to eq(undo_record.for_serialization)
+      end
+
+    end
+
+  end
+
+  context "when there is one undo record" do
+
+    # `Time.new` is stubbed later on, need to force it to be evaluated before
+    # then.
+    let!(:start_time) { Time.new }
+
+    let(:expected_id) { start_time.utc.strftime("%Y%m%d%H%M%S") }
+
+    let(:missing_id) { (start_time + 1).utc.strftime("%Y%m%d%H%M%S") }
+
+    before do
+      allow(Time).to receive(:new).and_return(start_time)
+      undo_stack.push(undo_record)
+    end
+
+    it "creates the item on disk" do
+      expect(File).to be_directory(undo_stack.undo_dir)
+      expect(undo_stack_files.size).to eq(1)
+    end
+
+    it "has one item" do
+      expect(undo_stack.size).to eq(1)
+    end
+
+    it "is not empty" do
+      expect(undo_stack).to_not be_empty
+    end
+
+    it "checks whether a record exists by id" do
+      expect(undo_stack).to have_id(expected_id)
+      expect(undo_stack).to_not have_id(missing_id)
+    end
+
+    it "deletes a record by id" do
+      expect(undo_stack.delete(expected_id)).to eq(undo_record)
+    end
+
+    it "deletes a record by id and yields it" do
+      expect { |b| undo_stack.delete(expected_id, &b) }.to yield_with_args(undo_record)
+    end
+
+    it "fails to delete a record that doesn't exist" do
+      expect { undo_stack.delete(missing_id) }.to raise_error(ChefDK::UndoRecordNotFound)
+    end
+
+    it "pops the last record" do
+      expect(undo_stack.pop).to eq(undo_record)
+    end
+
+    it "pops the last record and yields it" do
+      expect { |b| undo_stack.pop(&b) }.to yield_with_args(undo_record)
+    end
+
+    it "iterates over the records" do
+      expect { |b| undo_stack.each_with_id(&b) }.to yield_successive_args([expected_id, undo_record])
+    end
+
+    it "has the undo record that was pushed" do
+      expect(undo_stack.undo_records.size).to eq(1)
+      expect(undo_stack.undo_records).to eq( [ undo_record ] )
+    end
+
+    context "and the record is removed" do
+
+      let!(:popped_record) { undo_stack.pop }
+
+      it "has no items" do
+        expect(undo_stack_files.size).to eq(0)
+      end
+
+    end
+
+  end
+
+
+  context "when the stack is at the maximum configured size" do
+    # `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
+
+    def incremented_undo_record(i)
+      record = {
+        "name" => "appserver",
+        "revision_id" => i.to_s * 64
+      }
+
+      ChefDK::Policyfile::UndoRecord.new.tap do |undo_record|
+        undo_record.description = "delete-policy-group preprod-#{i}"
+        undo_record.add_policy_group("preprod-#{i}")
+        undo_record.add_policy_revision("appserver", "preprod-#{i}", record)
+      end
+    end
+
+    before do
+      ##  # UndoStack assumes you're not creating more than 1 undo record/second,
+      ##  # which is reasonable in the real world but won't work here.
+      allow(Time).to receive(:new) { next_time }
+
+      10.times { |i| undo_stack.push(incremented_undo_record(i)) }
+
+      expect(undo_stack_files.size).to eq(10)
+    end
+
+    describe "pushing a new undo record" do
+      it "does not exceed the maximum size" do
+        undo_stack.push(incremented_undo_record(11))
+
+        expect(undo_stack_files.size).to eq(10)
+      end
+
+      it "removes the oldest record" do
+        oldest_record_file = undo_stack_files.sort.first
+
+        undo_stack.push(incremented_undo_record(11))
+
+        expect(File.exist?(oldest_record_file)).to be(false)
+      end
+    end
+
+    context "when the stack is above maximum configured size" do
+
+      let(:older_record_path) do
+        record_id = (Time.new - (3600 * 24)).utc.strftime("%Y%m%d%H%M%S")
+        File.join(expected_undo_dir, record_id)
+      end
+
+      before do
+        FileUtils.touch(older_record_path)
+      expect(undo_stack_files.size).to eq(11)
+      end
+
+      describe "pushing a new undo record" do
+        it "does not exceed the maximum size" do
+          undo_stack.push(incremented_undo_record(11))
+
+          expect(undo_stack_files.size).to eq(10)
+        end
+
+        it "removes the oldest record" do
+          oldest_record_file = undo_stack_files.sort.first
+
+          undo_stack.push(incremented_undo_record(11))
+
+          expect(File.exist?(oldest_record_file)).to be(false)
+        end
+      end
+
+    end
+  end
+
+end