chef-apply 0.4.6 → 0.4.9

data/spec/unit/action/generate_local_policy_spec.rb

@@ -1,114 +0,0 @@
-#
-# Copyright:: Copyright (c) 2017 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_apply/action/generate_local_policy"
-require "chef-cli/policyfile_services/install"
-require "chef-cli/ui"
-require "chef-cli/policyfile_services/export_repo"
-
-RSpec.describe ChefApply::Action::GenerateLocalPolicy do
-  subject { ChefApply::Action::GenerateLocalPolicy.new(cookbook: cookbook) }
-  let(:cookbook) do
-    double("TempCookbook",
-      path: "/my/temp/cookbook",
-      export_path: "/my/temp/cookbook/export",
-      policyfile_lock_path: "/my/temp/cookbook/policyfile.lock")
-  end
-
-  let(:installer_double) do
-    instance_double(ChefCLI::PolicyfileServices::Install, run: :ok)
-  end
-
-  let(:exporter_double) do
-    instance_double(ChefCLI::PolicyfileServices::ExportRepo,
-      archive_file_location: "/path/to/export",
-      run: :ok)
-  end
-
-  before do
-    allow(subject).to receive(:notify)
-  end
-
-  describe "#perform_action" do
-    context "in the normal case" do
-      it "exports the policy notifying caller of progress, setting archive_file_location" do
-        expect(subject).to receive(:notify).ordered.with(:generating)
-        expect(subject).to receive(:installer).ordered.and_return installer_double
-        expect(installer_double).to receive(:run).ordered
-        expect(subject).to receive(:notify).ordered.with(:exporting)
-        expect(subject).to receive(:exporter).ordered.and_return exporter_double
-        expect(exporter_double).to receive(:run).ordered
-        expect(subject).to receive(:exporter).ordered.and_return exporter_double
-        expect(subject).to receive(:notify).ordered.with(:success)
-        subject.perform_action
-        expect(subject.archive_file_location).to eq("/path/to/export")
-      end
-    end
-
-    context "when PolicyfileServices raises an error" do
-      it "reraises as PolicyfileInstallError" do
-        expect(subject).to receive(:installer).and_return installer_double
-        expect(installer_double).to receive(:run).and_raise(ChefCLI::PolicyfileInstallError.new("", nil))
-        expect { subject.perform_action }.to raise_error(ChefApply::Action::PolicyfileInstallError)
-      end
-    end
-
-    context "when the path name is too long" do
-      let(:name) { "THIS_IS_A_REALLY_LONG_STRING111111111111111111111111111111111111111111111111111111" }
-
-      # There is an issue with policyfile generation where, if we have a cookbook with too long
-      # of a name or directory name the policyfile will not generate. This is because the tar
-      # library that ChefCLI uses comes from the Rubygems package and is meant for packaging
-      # gems up, so it can impose a 100 character limit. We attempt to solve this by ensuring
-      # that the paths/names we generate with `TempCookbook` are short.
-      #
-      # This is here for documentation
-      # 2018-05-18 mp addendum: this cna take upwards of 15s to run on ci nodes, pending
-      # for now since it's not testing any Chef Apply functionality.
-      xit "fails to create when there is a long path name" do
-        err = ChefCLI::PolicyfileExportRepoError
-        expect { subject.perform_action }.to raise_error(err) do |e|
-          expect(e.cause.class).to eq(Gem::Package::TooLongFileName)
-          expect(e.cause.message).to match(/should be 100 or less/)
-        end
-      end
-    end
-  end
-
-  describe "#exporter" do
-
-    it "returns a correctly constructed ExportRepo" do
-      expect(ChefCLI::PolicyfileServices::ExportRepo).to receive(:new)
-        .with(policyfile: cookbook.policyfile_lock_path,
-              root_dir: cookbook.path,
-              export_dir:  cookbook.export_path,
-              archive: true, force: true)
-        .and_return exporter_double
-      expect(subject.exporter).to eq exporter_double
-    end
-  end
-
-  describe "#installer" do
-    it "returns a correctly constructed Install service" do
-      expect(ChefCLI::PolicyfileServices::Install).to receive(:new)
-        .with(ui: ChefCLI::UI, root_dir: cookbook.path)
-        .and_return(installer_double)
-      expect(subject.installer).to eq installer_double
-    end
-  end
-
-end

data/spec/unit/action/generate_temp_cookbook/recipe_lookup_spec.rb

@@ -1,122 +0,0 @@
-#
-# Copyright:: Copyright (c) 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_apply/action/generate_temp_cookbook/recipe_lookup"
-require "chef/exceptions"
-require "chef/cookbook/cookbook_version_loader"
-require "chef/cookbook_version"
-require "chef/cookbook_loader"
-
-RSpec.describe ChefApply::Action::GenerateTempCookbook::RecipeLookup do
-  let(:repo_path) { "repo_path" }
-  subject(:rp) { ChefApply::Action::GenerateTempCookbook::RecipeLookup.new([repo_path]) }
-  VL = Chef::Cookbook::CookbookVersionLoader
-  let(:version_loader) { instance_double(VL) }
-  let(:cookbook_version) { instance_double(Chef::CookbookVersion, root_dir: "dir", name: "name") }
-  let(:cookbook_loader) { instance_double(Chef::CookbookLoader, load_cookbooks: nil) }
-
-  describe "#split" do
-    it "splits a customer provided specifier into a cookbook part and possible recipe part" do
-      expect(rp.split("/some/path")).to eq(%w{/some/path})
-      expect(rp.split("cookbook::recipe")).to eq(%w{cookbook recipe})
-    end
-  end
-
-  describe "#load_cookbook" do
-    context "when a directory is provided" do
-      let(:recipe_specifier) { "/some/directory" }
-      let(:default_recipe) { File.join(recipe_specifier, "default.rb") }
-      let(:recipes_by_name) { { "default" => default_recipe } }
-      before do
-        expect(File).to receive(:directory?).with(recipe_specifier).and_return(true)
-        expect(VL).to receive(:new).with(recipe_specifier).and_return(version_loader)
-      end
-
-      it "loads the cookbook and returns the path to the default recipe" do
-        expect(version_loader).to receive(:load!)
-        expect(version_loader).to receive(:cookbook_version).and_return(cookbook_version)
-        expect(rp.load_cookbook(recipe_specifier)).to eq(cookbook_version)
-      end
-
-      context "the directory is not a cookbook" do
-        it "raise an InvalidCookbook error" do
-          expect(version_loader).to receive(:load!).and_raise(Chef::Exceptions::CookbookNotFoundInRepo.new)
-          expect { rp.load_cookbook(recipe_specifier) }.to raise_error(ChefApply::Action::GenerateTempCookbook::RecipeLookup::InvalidCookbook)
-        end
-      end
-    end
-
-    context "when a cookbook name is provided" do
-      let(:recipe_specifier) { "cb" }
-      before do
-        expect(File).to receive(:directory?).with(recipe_specifier).and_return(false)
-        expect(Chef::CookbookLoader).to receive(:new).and_return(cookbook_loader)
-      end
-
-      context "and a cookbook in the cookbook repository exists with that name" do
-        it "returns the default cookbook" do
-          expect(cookbook_loader).to receive(:[]).with(recipe_specifier).and_return(cookbook_version)
-          expect(rp.load_cookbook(recipe_specifier)).to eq(cookbook_version)
-        end
-      end
-
-      context "and a cookbook exists but it is invalid" do
-        it "raises an InvalidCookbook error" do
-          expect(cookbook_loader).to receive(:[]).with(recipe_specifier).and_raise(Chef::Exceptions::CookbookNotFoundInRepo.new)
-          expect(File).to receive(:directory?).with(File.join(repo_path, recipe_specifier)).and_return(true)
-          expect { rp.load_cookbook(recipe_specifier) }.to raise_error(ChefApply::Action::GenerateTempCookbook::RecipeLookup::InvalidCookbook)
-        end
-      end
-
-      context "and a cookbook does not exist" do
-        it "raises an CookbookNotFound error" do
-          expect(cookbook_loader).to receive(:[]).with(recipe_specifier).and_raise(Chef::Exceptions::CookbookNotFoundInRepo.new)
-          expect(File).to receive(:directory?).with(File.join(repo_path, recipe_specifier)).and_return(false)
-          expect { rp.load_cookbook(recipe_specifier) }.to raise_error(ChefApply::Action::GenerateTempCookbook::RecipeLookup::CookbookNotFound)
-        end
-      end
-    end
-  end
-
-  describe "#find_recipe" do
-    let(:recipe) { double("recipe") }
-
-    context "no recipe is specified" do
-      it "finds a default recipe" do
-        expect(cookbook_version).to receive(:recipe_filenames_by_name).and_return({ "default" => recipe })
-        expect(rp.find_recipe(cookbook_version)).to eq(recipe)
-      end
-      it "when there is no default recipe it raises a NoDefaultRecipe error" do
-        expect(cookbook_version).to receive(:recipe_filenames_by_name).and_return({})
-        expect { rp.find_recipe(cookbook_version) }.to raise_error(ChefApply::Action::GenerateTempCookbook::RecipeLookup::NoDefaultRecipe)
-      end
-    end
-
-    context "a recipe is specified" do
-      let(:desired_recipe) { "a_recipe" }
-      it "finds the specified recipe" do
-        expect(cookbook_version).to receive(:recipe_filenames_by_name).and_return({ desired_recipe => recipe })
-        expect(rp.find_recipe(cookbook_version, desired_recipe)).to eq(recipe)
-      end
-      it "when there is no recipe with that name it raises a RecipeNotFound error" do
-        expect(cookbook_version).to receive(:recipe_filenames_by_name).and_return({})
-        expect { rp.find_recipe(cookbook_version, desired_recipe) }.to raise_error(ChefApply::Action::GenerateTempCookbook::RecipeLookup::RecipeNotFound)
-      end
-    end
-  end
-end

data/spec/unit/action/generate_temp_cookbook/temp_cookbook_spec.rb

@@ -1,198 +0,0 @@
-#
-# Copyright:: Copyright (c) 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 "tempfile"
-require "securerandom"
-require "chef_apply/action/generate_temp_cookbook/temp_cookbook"
-RSpec.describe "ChefApply::Action::GenerateTempCookbook::TempCookbook" do
-  subject(:tc) { ChefApply::Action::GenerateTempCookbook::TempCookbook.new }
-  let(:uuid) { SecureRandom.uuid }
-
-  before do
-    @repo_paths = ChefApply::Config.chef.cookbook_repo_paths
-    ChefApply::Config.chef.cookbook_repo_paths = []
-  end
-
-  after do
-    ChefApply::Config.chef.cookbook_repo_paths = @repo_paths
-    subject.delete
-  end
-
-  describe "#from_existing_recipe" do
-    it "raises an error if the recipe does not have a .rb extension" do
-      err = ChefApply::Action::GenerateTempCookbook::TempCookbook::UnsupportedExtension
-      expect { subject.from_existing_recipe("/some/file.chef") }.to raise_error(err)
-    end
-
-    context "when there is an existing cookbook" do
-      let(:cb) do
-        d = Dir.mktmpdir
-        File.open(File.join(d, "metadata.rb"), "w+") do |f|
-          f << "name \"foo\""
-        end
-        FileUtils.mkdir(File.join(d, "recipes"))
-        d
-      end
-
-      let(:existing_recipe) do
-        File.open(File.join(cb, "recipes/default.rb"), "w+") do |f|
-          f.write(uuid)
-          f
-        end
-      end
-
-      after do
-        FileUtils.remove_entry cb
-      end
-
-      it "copies the whole cookbook" do
-        subject.from_existing_recipe(existing_recipe.path)
-        expect(File.read(File.join(subject.path, "recipes/default.rb"))).to eq(uuid)
-        expect(File.read(File.join(subject.path, "Policyfile.rb"))).to eq <<~EXPECTED_POLICYFILE
-          name "foo_policy"
-          default_source :supermarket
-          run_list "foo::default"
-          cookbook "foo", path: "."
-        EXPECTED_POLICYFILE
-        expect(File.read(File.join(subject.path, "metadata.rb"))).to eq("name \"foo\"")
-      end
-    end
-
-    context "when there is only a single recipe not in a cookbook" do
-      let(:existing_recipe) do
-        t = Tempfile.new(["recipe", ".rb"])
-        t.write(uuid)
-        t.close
-        t
-      end
-
-      after do
-        existing_recipe.unlink
-      end
-
-      it "copies the existing recipe into a new cookbook" do
-        subject.from_existing_recipe(existing_recipe.path)
-        recipe_filename = File.basename(existing_recipe.path)
-        recipe_name = File.basename(recipe_filename, File.extname(recipe_filename))
-        expect(File.read(File.join(subject.path, "recipes/", recipe_filename))).to eq(uuid)
-        expect(File.read(File.join(subject.path, "Policyfile.rb"))).to eq <<~EXPECTED_POLICYFILE
-          name "cw_recipe_policy"
-          default_source :supermarket
-          run_list "cw_recipe::#{recipe_name}"
-          cookbook "cw_recipe", path: "."
-        EXPECTED_POLICYFILE
-        expect(File.read(File.join(subject.path, "metadata.rb"))).to eq("name \"cw_recipe\"\n")
-      end
-    end
-  end
-
-  describe "#from_resource" do
-    it "creates a recipe containing the supplied recipe" do
-      subject.from_resource("directory", "/tmp/foo", [])
-      expect(File.read(File.join(subject.path, "recipes/default.rb"))).to eq("directory '/tmp/foo'\n")
-    end
-  end
-
-  describe "#generate_metadata" do
-    it "generates metadata in the temp cookbook" do
-      f = subject.generate_metadata("foo")
-      expect(File.read(f)).to eq("name \"foo\"\n")
-    end
-  end
-
-  describe "#generate_policyfile" do
-    context "when there is no existing policyfile" do
-      it "generates a policyfile in the temp cookbook" do
-        f = subject.generate_policyfile("foo", "bar")
-        expect(File.read(f)).to eq <<~EXPECTED_POLICYFILE
-          name "foo_policy"
-          default_source :supermarket
-          run_list "foo::bar"
-          cookbook "foo", path: "."
-        EXPECTED_POLICYFILE
-      end
-
-      context "when there are configured cookbook_repo_paths" do
-        it "generates a policyfile in the temp cookbook" do
-          ChefApply::Config.chef.cookbook_repo_paths = %w{one two}
-          f = subject.generate_policyfile("foo", "bar")
-          expect(File.read(f)).to eq <<~EXPECTED_POLICYFILE
-            name "foo_policy"
-            default_source :chef_repo, "one"
-            default_source :chef_repo, "two"
-            default_source :supermarket
-            run_list "foo::bar"
-            cookbook "foo", path: "."
-          EXPECTED_POLICYFILE
-        end
-      end
-    end
-
-    context "when there is an existing policyfile" do
-      before do
-        File.open(File.join(subject.path, "Policyfile.rb"), "a") do |f|
-          f << "this is a policyfile"
-        end
-      end
-      it "only overrides the existing run_list in the policyfile" do
-        f = subject.generate_policyfile("foo", "bar")
-        expect(File.read(f)).to eq <<~EXPECTED_POLICYFILE
-          this is a policyfile
-          # Overriding run_list with command line specified value
-          run_list "foo::bar"
-        EXPECTED_POLICYFILE
-      end
-    end
-  end
-
-  describe "#create_resource_definition" do
-    let(:r1) { "directory" }
-    let(:r2) { "/tmp" }
-    let(:props) { nil }
-    context "when no properties are provided" do
-      it "it creates a simple resource" do
-        expect(subject.create_resource_definition(r1, r2, [])).to eq("directory '/tmp'\n")
-      end
-    end
-
-    context "when properties are provided" do
-      let(:props) do
-        {
-          "key1" => "value",
-          "key2" => 0.1,
-          "key3" => 100,
-          "key4" => true,
-          "key_with_underscore" => "value",
-        }
-      end
-
-      it "converts the properties to chef-client args" do
-        expected = <<~EXPECTED_RESOURCE
-          directory '/tmp' do
-            key1 'value'
-            key2 0.1
-            key3 100
-            key4 true
-            key_with_underscore 'value'
-          end
-        EXPECTED_RESOURCE
-        expect(subject.create_resource_definition(r1, r2, props)).to eq(expected)
-      end
-    end
-  end
-end

data/spec/unit/action/generate_temp_cookbook_spec.rb

@@ -1,73 +0,0 @@
-#
-# Copyright:: Copyright (c) 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 "chef_apply/action/generate_temp_cookbook"
-
-RSpec.describe ChefApply::Action::GenerateTempCookbook do
-  let(:options) { {} }
-  subject { ChefApply::Action::GenerateTempCookbook }
-
-  describe ".from_options" do
-    context "when given options for a recipe" do
-      let(:options) { { recipe_spec: "some::recipe" } }
-      it "returns a GenerateCookbookFromRecipe action" do
-        expect(subject.from_options(options)).to be_a(ChefApply::Action::GenerateCookbookFromRecipe)
-      end
-    end
-
-    context "when given options for a resource" do
-      let(:resource_properties) { {} }
-      let(:options) do
-        { resource_name: "user1", resource_type: "user",
-          resource_properties: resource_properties }
-      end
-
-      it "returns a GenerateCookbookFromResource action" do
-        expect(subject.from_options(options)).to be_a ChefApply::Action::GenerateCookbookFromResource
-      end
-    end
-
-    context "when not given sufficient options for either" do
-      let(:options) { {} }
-      it "raises MissingOptions" do
-        expect { subject.from_options(options) }.to raise_error ChefApply::Action::MissingOptions
-      end
-    end
-
-  end
-
-  describe "#perform_action" do
-    subject { ChefApply::Action::GenerateTempCookbook.new( {} ) }
-    it "generates a cookbook, notifies caller, and makes the cookbook available" do
-      expect(subject).to receive(:notify).ordered.with(:generating)
-      expect(subject).to receive(:generate)
-      expect(subject).to receive(:notify).ordered.with(:success)
-      subject.perform_action
-      expect(subject.generated_cookbook).to_not be nil
-    end
-
-  end
-
-end
-
-RSpec.describe ChefApply::Action::GenerateCookbookFromRecipe do
-  xit "#generate", "Please implement me"
-end
-
-RSpec.describe ChefApply::Action::GenerateCookbookFromResource do
-  xit "#generate", "Please implement me"
-end