chef-cli 1.0.3

data/spec/unit/policyfile/source_uri_spec.rb

@@ -0,0 +1,36 @@
+#
+# Copyright:: Copyright (c) 2016 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/source_uri"
+
+describe ChefCLI::Policyfile::SourceURI do
+  subject { described_class.parse(source_uri) }
+
+  describe "#validate" do
+    context "when the scheme is not https" do
+      let(:source_uri) { "ftp://chef.example.com" }
+
+      it "raises ChefCLI::InvalidPolicyfileSourceURI" do
+        expect do
+          subject.validate
+        end.to raise_error(ChefCLI::InvalidPolicyfileSourceURI)
+      end
+    end
+  end
+end

data/spec/unit/policyfile/storage_config_spec.rb

@@ -0,0 +1,180 @@
+#
+# Copyright:: Copyright (c) 2014-2018 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/storage_config"
+
+describe ChefCLI::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
+
+    it "generates the location of the policyfile lock" do
+      expect(storage_config.policyfile_lock_filename).to eq("/path/to/Policyfile.lock.json")
+    end
+
+    it "gives the expanded path to the policyfile" do
+      expect(storage_config.policyfile_expanded_path).to eq(File.expand_path("/path/to/Policyfile.rb"))
+    end
+
+    context "when the policyfile is given as a relative path" do
+
+      before do
+        storage_config.use_policyfile("Policyfile.rb")
+      end
+
+      it "updates the relative_paths_root to be relative to a policyfile" do
+        expect(storage_config.relative_paths_root).to eq(".")
+      end
+
+      it "stores the location of the policyfile" do
+        expect(storage_config.policyfile_filename).to eq("Policyfile.rb")
+      end
+
+      it "generates the location of the policyfile lock" do
+        expect(storage_config.policyfile_lock_filename).to eq("Policyfile.lock.json")
+      end
+
+      it "gives the expanded path to the policyfile" do
+        expect(storage_config.policyfile_expanded_path).to eq(File.expand_path("Policyfile.rb", "."))
+      end
+
+    end
+
+    context "when the policyfile file name doesn't have a .rb extension" do
+
+      it "raises an error" do
+        err_string = %q{Policyfile filenames must end with `.rb' extension (you gave: `Policyfile')}
+        expect { storage_config.use_policyfile("Policyfile") }.to raise_error(ChefCLI::InvalidPolicyfileFilename, err_string)
+      end
+
+    end
+
+    context "when the policyfile file name is actually a lockfile" do
+
+      before do
+        storage_config.use_policyfile("foo.lock.json")
+      end
+
+      it "uses the policyfile .rb file instead" do
+        expect(storage_config.policyfile_filename).to eq("foo.rb")
+      end
+
+    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 lock" do
+      expect(storage_config.policyfile_lock_filename).to eq("/path/to/Policyfile.lock.json")
+    end
+
+    it "stores the location of the policyfile" do
+      expect(storage_config.policyfile_filename).to eq("/path/to/Policyfile.rb")
+    end
+
+    it "gives the expanded path to the policyfile lock" do
+      expect(storage_config.policyfile_lock_expanded_path).to eq(File.expand_path("/path/to/Policyfile.lock.json"))
+    end
+
+    context "when given a relative path to the policyfile lock" do
+
+      before do
+        storage_config.use_policyfile_lock("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(".")
+      end
+
+      it "stores the location of the policyfile" do
+        expect(storage_config.policyfile_filename).to eq("Policyfile.rb")
+      end
+
+      it "generates the location of the policyfile lock" do
+        expect(storage_config.policyfile_lock_filename).to eq("Policyfile.lock.json")
+      end
+
+      it "gives the expanded path to the policyfile" do
+        expect(storage_config.policyfile_lock_expanded_path).to eq(File.expand_path("Policyfile.lock.json", "."))
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/policyfile/undo_record_spec.rb

@@ -0,0 +1,258 @@
+#
+# 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/undo_record"
+
+describe ChefCLI::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(ChefCLI::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(ChefCLI::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(ChefCLI::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(ChefCLI::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(ChefCLI::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(ChefCLI::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(ChefCLI::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