chef-apply 0.3.3 → 0.4.6

data/spec/unit/action/converge_target_spec.rb

@@ -16,10 +16,9 @@
 #
 
 require "spec_helper"
-require "chef_apply/action/converge_target"
 require "chef_apply/target_host"
-require "chef_apply/errors/ccr_failure_mapper"
-require "chef_apply/temp_cookbook"
+require "chef_apply/action/converge_target"
+require "chef_apply/action/converge_target/ccr_failure_mapper"
 
 RSpec.describe ChefApply::Action::ConvergeTarget do
   let(:archive) { "archive.tgz" }
@@ -29,7 +28,7 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
   let(:target_host) do
     p = double("platform", family: platform_family)
     double(ChefApply::TargetHost,
-           platform: p, base_os: base_os, ws_cache_path: cache_path)
+      platform: p, base_os: base_os, ws_cache_path: cache_path)
   end
   let(:local_policy_path) { "/local/policy/path/archive.tgz" }
   let(:opts) { { target_host: target_host, local_policy_path: local_policy_path } }
@@ -102,7 +101,7 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
           exception_handlers << reporter
           chef_license "accept-no-persist"
         EOM
-        )
+                                                      )
         expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path)
         expect(subject.create_remote_config(remote_folder)).to eq(remote_config_path)
         expect(local_tempfile.closed?).to eq(true)
@@ -126,7 +125,7 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
           report_handlers << reporter
           exception_handlers << reporter
         EOM
-        )
+                                                      )
         expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path)
         expect(subject.create_remote_config(remote_folder)).to eq(remote_config_path)
         expect(local_tempfile.closed?).to eq(true)
@@ -155,7 +154,7 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
           exception_handlers << reporter
           log_level :info
         EOM
-        )
+                                                      )
         expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path)
         expect(subject.create_remote_config(remote_folder)).to eq(remote_config_path)
         expect(local_tempfile.closed?).to eq(true)
@@ -188,7 +187,7 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
           data_collector.mode :solo
           data_collector.organization "Chef Workstation"
         EOM
-        )
+                                                      )
         expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path)
         expect(subject.create_remote_config(remote_folder)).to eq(remote_config_path)
       # ensure the tempfile is deleted locally
@@ -214,7 +213,7 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
           report_handlers << reporter
           exception_handlers << reporter
         EOM
-        )
+                                                      )
         expect(target_host).to receive(:upload_file).with(local_tempfile.path, remote_config_path)
         expect(subject.create_remote_config(remote_folder)).to eq(remote_config_path)
         # ensure the tempfile is deleted locally
@@ -303,11 +302,11 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
       # Note we're only ensuring the command looks the same as #run_chef_cmd - we verify that run_chef_cmd
       # is correct in its own test elsewhere in this file
       expect(target_host).to receive(:run_command).with(subject.run_chef_cmd(remote_folder,
-                                                                             "workstation.rb",
-                                                                             "archive.tgz")).and_return result
+        "workstation.rb",
+        "archive.tgz")).and_return result
       expect(target_host).to receive(:del_dir).with(remote_folder).and_return result
 
-      [:running_chef, :success].each do |n|
+      %i{running_chef success}.each do |n|
         expect(subject).to receive(:notify).with(n)
       end
       subject.perform_action
@@ -318,10 +317,10 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
 
       it "runs the converge and reports back reboot" do
         expect(target_host).to receive(:run_command).with(subject.run_chef_cmd(remote_folder,
-                                                                               "workstation.rb",
-                                                                               "archive.tgz")).and_return result
+          "workstation.rb",
+          "archive.tgz")).and_return result
         expect(target_host).to receive(:del_dir).with(remote_folder).and_return result
-        [:running_chef, :reboot].each do |n|
+        %i{running_chef reboot}.each do |n|
           expect(subject).to receive(:notify).with(n)
         end
         subject.perform_action
@@ -333,16 +332,16 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
       let(:report_result) { '{ "exception": "thing" }' }
       let(:exception_mapper) { double("mapper") }
       before do
-        expect(ChefApply::Errors::CCRFailureMapper).to receive(:new)
+        expect(ChefApply::Action::ConvergeTarget::CCRFailureMapper).to receive(:new)
           .and_return exception_mapper
       end
 
       it "reports back failure and reads the remote report" do
         expect(target_host).to receive(:run_command).with(subject.run_chef_cmd(remote_folder,
-                                                                               "workstation.rb",
-                                                                               "archive.tgz")).and_return result
+          "workstation.rb",
+          "archive.tgz")).and_return result
         expect(target_host).to receive(:del_dir).with(remote_folder).and_return result
-        [:running_chef, :converge_error].each do |n|
+        %i{running_chef converge_error}.each do |n|
           expect(subject).to receive(:notify).with(n)
         end
         expect(target_host).to receive(:fetch_file_contents).with(subject.chef_report_path).and_return(report_result)
@@ -355,10 +354,10 @@ RSpec.describe ChefApply::Action::ConvergeTarget do
         let(:report_result) { nil }
         it "reports back failure" do
           expect(target_host).to receive(:run_command).with(subject.run_chef_cmd(remote_folder,
-                                                                                 "workstation.rb",
-                                                                                 "archive.tgz")).and_return result
+            "workstation.rb",
+            "archive.tgz")).and_return result
           expect(target_host).to receive(:del_dir).with(remote_folder).and_return result
-          [:running_chef, :converge_error].each do |n|
+          %i{running_chef converge_error}.each do |n|
             expect(subject).to receive(:notify).with(n)
           end
           expect(target_host).to receive(:fetch_file_contents).with(subject.chef_report_path).and_return(report_result)

data/spec/unit/action/generate_local_policy_spec.rb

@@ -24,9 +24,9 @@ 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")
+      path: "/my/temp/cookbook",
+      export_path: "/my/temp/cookbook/export",
+      policyfile_lock_path: "/my/temp/cookbook/policyfile.lock")
   end
 
   let(:installer_double) do
@@ -35,8 +35,8 @@ RSpec.describe ChefApply::Action::GenerateLocalPolicy do
 
   let(:exporter_double) do
     instance_double(ChefCLI::PolicyfileServices::ExportRepo,
-                    archive_file_location: "/path/to/export",
-                    run: :ok)
+      archive_file_location: "/path/to/export",
+      run: :ok)
   end
 
   before do

data/spec/unit/{recipe_lookup_spec.rb → action/generate_temp_cookbook/recipe_lookup_spec.rb}

@@ -16,15 +16,15 @@
 #
 
 require "spec_helper"
-require "chef_apply/recipe_lookup"
+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::RecipeLookup do
+RSpec.describe ChefApply::Action::GenerateTempCookbook::RecipeLookup do
   let(:repo_path) { "repo_path" }
-  subject(:rp) { ChefApply::RecipeLookup.new([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") }
@@ -56,7 +56,7 @@ RSpec.describe ChefApply::RecipeLookup do
       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::RecipeLookup::InvalidCookbook)
+          expect { rp.load_cookbook(recipe_specifier) }.to raise_error(ChefApply::Action::GenerateTempCookbook::RecipeLookup::InvalidCookbook)
         end
       end
     end
@@ -77,17 +77,17 @@ RSpec.describe ChefApply::RecipeLookup do
 
       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(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::RecipeLookup::InvalidCookbook)
+          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(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::RecipeLookup::CookbookNotFound)
+          expect { rp.load_cookbook(recipe_specifier) }.to raise_error(ChefApply::Action::GenerateTempCookbook::RecipeLookup::CookbookNotFound)
         end
       end
     end
@@ -103,7 +103,7 @@ RSpec.describe ChefApply::RecipeLookup do
       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::RecipeLookup::NoDefaultRecipe)
+        expect { rp.find_recipe(cookbook_version) }.to raise_error(ChefApply::Action::GenerateTempCookbook::RecipeLookup::NoDefaultRecipe)
       end
     end
 
@@ -115,7 +115,7 @@ RSpec.describe ChefApply::RecipeLookup do
       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::RecipeLookup::RecipeNotFound)
+        expect { rp.find_recipe(cookbook_version, desired_recipe) }.to raise_error(ChefApply::Action::GenerateTempCookbook::RecipeLookup::RecipeNotFound)
       end
     end
   end

data/spec/unit/{temp_cookbook_spec.rb → action/generate_temp_cookbook/temp_cookbook_spec.rb}

@@ -16,12 +16,11 @@
 #
 
 require "spec_helper"
-require "chef_apply/temp_cookbook"
 require "tempfile"
 require "securerandom"
-
-RSpec.describe ChefApply::TempCookbook do
-  subject(:tc) { ChefApply::TempCookbook.new }
+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
@@ -31,13 +30,13 @@ RSpec.describe ChefApply::TempCookbook do
 
   after do
     ChefApply::Config.chef.cookbook_repo_paths = @repo_paths
-    tc.delete
+    subject.delete
   end
 
   describe "#from_existing_recipe" do
     it "raises an error if the recipe does not have a .rb extension" do
-      err = ChefApply::TempCookbook::UnsupportedExtension
-      expect { tc.from_existing_recipe("/some/file.chef") }.to raise_error(err)
+      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
@@ -62,15 +61,15 @@ RSpec.describe ChefApply::TempCookbook do
       end
 
       it "copies the whole cookbook" do
-        tc.from_existing_recipe(existing_recipe.path)
-        expect(File.read(File.join(tc.path, "recipes/default.rb"))).to eq(uuid)
-        expect(File.read(File.join(tc.path, "Policyfile.rb"))).to eq <<~EXPECTED_POLICYFILE
+        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(tc.path, "metadata.rb"))).to eq("name \"foo\"")
+        expect(File.read(File.join(subject.path, "metadata.rb"))).to eq("name \"foo\"")
       end
     end
 
@@ -87,31 +86,31 @@ RSpec.describe ChefApply::TempCookbook do
       end
 
       it "copies the existing recipe into a new cookbook" do
-        tc.from_existing_recipe(existing_recipe.path)
+        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(tc.path, "recipes/", recipe_filename))).to eq(uuid)
-        expect(File.read(File.join(tc.path, "Policyfile.rb"))).to eq <<~EXPECTED_POLICYFILE
+        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(tc.path, "metadata.rb"))).to eq("name \"cw_recipe\"\n")
+        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
-      tc.from_resource("directory", "/tmp/foo", [])
-      expect(File.read(File.join(tc.path, "recipes/default.rb"))).to eq("directory '/tmp/foo'\n")
+      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 = tc.generate_metadata("foo")
+      f = subject.generate_metadata("foo")
       expect(File.read(f)).to eq("name \"foo\"\n")
     end
   end
@@ -119,7 +118,7 @@ RSpec.describe ChefApply::TempCookbook do
   describe "#generate_policyfile" do
     context "when there is no existing policyfile" do
       it "generates a policyfile in the temp cookbook" do
-        f = tc.generate_policyfile("foo", "bar")
+        f = subject.generate_policyfile("foo", "bar")
         expect(File.read(f)).to eq <<~EXPECTED_POLICYFILE
           name "foo_policy"
           default_source :supermarket
@@ -131,7 +130,7 @@ RSpec.describe ChefApply::TempCookbook do
       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 = tc.generate_policyfile("foo", "bar")
+          f = subject.generate_policyfile("foo", "bar")
           expect(File.read(f)).to eq <<~EXPECTED_POLICYFILE
             name "foo_policy"
             default_source :chef_repo, "one"
@@ -146,12 +145,12 @@ RSpec.describe ChefApply::TempCookbook do
 
     context "when there is an existing policyfile" do
       before do
-        File.open(File.join(tc.path, "Policyfile.rb"), "a") do |f|
+        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 = tc.generate_policyfile("foo", "bar")
+        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
@@ -167,7 +166,7 @@ RSpec.describe ChefApply::TempCookbook do
     let(:props) { nil }
     context "when no properties are provided" do
       it "it creates a simple resource" do
-        expect(tc.create_resource_definition(r1, r2, [])).to eq("directory '/tmp'\n")
+        expect(subject.create_resource_definition(r1, r2, [])).to eq("directory '/tmp'\n")
       end
     end
 
@@ -192,7 +191,7 @@ RSpec.describe ChefApply::TempCookbook do
             key_with_underscore 'value'
           end
         EXPECTED_RESOURCE
-        expect(tc.create_resource_definition(r1, r2, props)).to eq(expected)
+        expect(subject.create_resource_definition(r1, r2, props)).to eq(expected)
       end
     end
   end

data/spec/unit/action/generate_temp_cookbook_spec.rb

@@ -33,7 +33,8 @@ RSpec.describe ChefApply::Action::GenerateTempCookbook do
       let(:resource_properties) { {} }
       let(:options) do
         { resource_name: "user1", resource_type: "user",
-          resource_properties: resource_properties } end
+          resource_properties: resource_properties }
+      end
 
       it "returns a GenerateCookbookFromResource action" do
         expect(subject.from_options(options)).to be_a ChefApply::Action::GenerateCookbookFromResource
@@ -52,7 +53,6 @@ RSpec.describe ChefApply::Action::GenerateTempCookbook do
   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)
@@ -65,11 +65,9 @@ RSpec.describe ChefApply::Action::GenerateTempCookbook do
 end
 
 RSpec.describe ChefApply::Action::GenerateCookbookFromRecipe do
-  describe "#generate" do
-  end
+  xit "#generate", "Please implement me"
 end
 
 RSpec.describe ChefApply::Action::GenerateCookbookFromResource do
-  describe "#generate" do
-  end
+  xit "#generate", "Please implement me"
 end

data/spec/unit/{minimum_chef_version_spec.rb → action/install_chef/minimum_chef_version_spec.rb}

@@ -15,15 +15,15 @@
 # limitations under the License.
 #
 
-require "chef_apply/minimum_chef_version"
+require "chef_apply/action/install_chef/minimum_chef_version"
 require "chef_apply/target_host"
 require "spec_helper"
 
-RSpec.describe ChefApply::MinimumChefVersion do
+RSpec.describe ChefApply::Action::InstallChef::MinimumChefVersion do
   let(:base_os) { :linux }
   let(:version) { 14 }
   let(:target) { instance_double(ChefApply::TargetHost, base_os: base_os, installed_chef_version: version) }
-  subject(:klass) { ChefApply::MinimumChefVersion }
+  subject(:klass) { ChefApply::Action::InstallChef::MinimumChefVersion }
 
   context "#check!" do
     context "when chef is not already installed on target" do
@@ -41,17 +41,17 @@ RSpec.describe ChefApply::MinimumChefVersion do
         it "raises ClientNotInstalled" do
           expect do
             klass.check!(target, true)
-          end.to raise_error(ChefApply::MinimumChefVersion::ClientNotInstalled)
+          end.to raise_error(ChefApply::Action::InstallChef::MinimumChefVersion::ClientNotInstalled)
         end
       end
     end
 
-    [:windows, :linux].each do |os|
+    %i{windows linux}.each do |os|
       context "on #{os}" do
         let(:base_os) { os }
         [13, 14].each do |major_version|
           context "when chef is already installed at the correct minimum Chef #{major_version} version" do
-            let(:version) { ChefApply::MinimumChefVersion::CONSTRAINTS[os][major_version] }
+            let(:version) { ChefApply::Action::InstallChef::MinimumChefVersion::CONSTRAINTS[os][major_version] }
             it "should return :minimum_version_met" do
               actual = klass.check!(target, false)
               expect(:minimum_version_met).to eq(actual)
@@ -63,17 +63,17 @@ RSpec.describe ChefApply::MinimumChefVersion do
 
     installed_expected = {
       windows: {
-        Gem::Version.new("12.1.1") => ChefApply::MinimumChefVersion::Client13Outdated,
-        Gem::Version.new("13.9.0") => ChefApply::MinimumChefVersion::Client13Outdated,
-        Gem::Version.new("14.3.37") => ChefApply::MinimumChefVersion::Client14Outdated,
+        Gem::Version.new("12.1.1") => ChefApply::Action::InstallChef::MinimumChefVersion::Client13Outdated,
+        Gem::Version.new("13.9.0") => ChefApply::Action::InstallChef::MinimumChefVersion::Client13Outdated,
+        Gem::Version.new("14.3.37") => ChefApply::Action::InstallChef::MinimumChefVersion::Client14Outdated,
       },
       linux: {
-        Gem::Version.new("12.1.1") => ChefApply::MinimumChefVersion::Client13Outdated,
-        Gem::Version.new("13.9.0") => ChefApply::MinimumChefVersion::Client13Outdated,
-        Gem::Version.new("14.1.0") => ChefApply::MinimumChefVersion::Client14Outdated,
+        Gem::Version.new("12.1.1") => ChefApply::Action::InstallChef::MinimumChefVersion::Client13Outdated,
+        Gem::Version.new("13.9.0") => ChefApply::Action::InstallChef::MinimumChefVersion::Client13Outdated,
+        Gem::Version.new("14.1.0") => ChefApply::Action::InstallChef::MinimumChefVersion::Client14Outdated,
       },
     }
-    [:windows, :linux].each do |os|
+    %i{windows linux}.each do |os|
       context "on #{os}" do
         let(:base_os) { os }
         installed_expected[os].each do |installed, expected|