chef-dk 2.6.2 → 3.0.36

data/spec/unit/command/export_spec.rb

@@ -1,199 +1,199 @@
-#
-# Copyright:: Copyright (c) 2014 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 "shared/command_with_ui_object"
-require "chef-dk/command/export"
-
-describe ChefDK::Command::Export do
-
-  it_behaves_like "a command with a UI object"
-
-  let(:params) { [] }
-
-  let(:command) do
-    described_class.new
-  end
-
-  let(:policyfile_lock) do
-    instance_double(ChefDK::PolicyfileLock, name: "example-policy")
-  end
-
-  let(:export_service) do
-    instance_double(ChefDK::PolicyfileServices::ExportRepo,
-                    policyfile_lock: policyfile_lock)
-  end
-
-  context "after evaluating params" do
-
-    let(:params) { [ "path/to/export" ] }
-
-    before do
-      command.apply_params!(params)
-    end
-
-    it "disables debug by default" do
-      expect(command.debug?).to be(false)
-    end
-
-    context "when debug mode is set" do
-
-      let(:params) { [ "path/to/export", "-D" ] }
-
-      it "enables debug" do
-        expect(command.debug?).to be(true)
-      end
-    end
-
-    context "when archive mode is set" do
-
-      let(:params) { [ "path/to/export", "-a" ] }
-
-      it "enables archiving the exported repo" do
-        expect(command.archive?).to be(true)
-      end
-
-      it "configures the export service to archive" do
-        expect(command.export_service.archive?).to be(true)
-      end
-    end
-
-    context "when the path to the exported repo is given" do
-
-      let(:params) { [ "path/to/export" ] }
-
-      it "configures the export service with the export path" do
-        expect(command.export_service.export_dir).to eq(File.expand_path("path/to/export"))
-      end
-
-      it "uses the default policyfile name" do
-        expect(command.export_service.policyfile_filename).to eq(File.expand_path("Policyfile.rb"))
-      end
-
-    end
-
-    context "when a Policyfile relative path and export path are given" do
-
-      let(:params) { [ "CustomNamedPolicy.rb", "path/to/export" ] }
-
-      it "configures the export service with the export path" do
-        expect(command.export_service.export_dir).to eq(File.expand_path("path/to/export"))
-      end
-
-      it "configures the export service with the policyfile relative path" do
-        expect(command.export_service.policyfile_filename).to eq(File.expand_path("CustomNamedPolicy.rb"))
-      end
-    end
-  end
-
-  describe "running the export" do
-
-    let(:params) { [ "/path/to/export" ] }
-
-    let(:ui) { TestHelpers::TestUI.new }
-
-    before do
-      command.ui = ui
-      allow(command).to receive(:export_service).and_return(export_service)
-    end
-
-    context "with no arguments" do
-
-      it "exits non-zero and prints a help message" do
-        expect(command.run).to eq(1)
-      end
-
-    end
-
-    context "when the command is successful" do
-
-      before do
-        expect(export_service).to receive(:run)
-      end
-
-      it "returns 0" do
-        expect(command.run(params)).to eq(0)
-      end
-
-      it "prints instructions for running chef-client in the repo" do
-        command.run(params)
-
-        expected_message = <<-MESSAGE
-To converge this system with the exported policy, run:
-  cd /path/to/export
-  chef-client -z
-MESSAGE
-        expect(ui.output).to include(expected_message)
-      end
-    end
-
-    context "when the command is unsuccessful" do
-
-      let(:backtrace) { caller[0...3] }
-
-      let(:cause) do
-        e = StandardError.new("some operation failed")
-        e.set_backtrace(backtrace)
-        e
-      end
-
-      let(:exception) do
-        ChefDK::PolicyfileExportRepoError.new("export failed", cause)
-      end
-
-      before do
-        expect(export_service).to receive(:run).and_raise(exception)
-      end
-
-      it "returns 1" do
-        expect(command.run(params)).to eq(1)
-      end
-
-      it "displays the exception and cause" do
-        expected_error_text = <<-E
-Error: export failed
-Reason: (StandardError) some operation failed
-
-E
-
-        command.run(params)
-        expect(ui.output).to eq(expected_error_text)
-      end
-
-      context "and debug is enabled" do
-
-        let(:params) { [ "path/to/export", "-D"] }
-
-        it "displays the exception and cause with backtrace" do
-          expected_error_text = <<-E
-Error: export failed
-Reason: (StandardError) some operation failed
-
-
-E
-
-          expected_error_text << backtrace.join("\n") << "\n"
-
-          command.run(params)
-          expect(ui.output).to eq(expected_error_text)
-        end
-      end
-
-    end
-
-  end
-end
+#
+# 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 "shared/command_with_ui_object"
+require "chef-dk/command/export"
+
+describe ChefDK::Command::Export do
+
+  it_behaves_like "a command with a UI object"
+
+  let(:params) { [] }
+
+  let(:command) do
+    described_class.new
+  end
+
+  let(:policyfile_lock) do
+    instance_double(ChefDK::PolicyfileLock, name: "example-policy")
+  end
+
+  let(:export_service) do
+    instance_double(ChefDK::PolicyfileServices::ExportRepo,
+                    policyfile_lock: policyfile_lock)
+  end
+
+  context "after evaluating params" do
+
+    let(:params) { [ "path/to/export" ] }
+
+    before do
+      command.apply_params!(params)
+    end
+
+    it "disables debug by default" do
+      expect(command.debug?).to be(false)
+    end
+
+    context "when debug mode is set" do
+
+      let(:params) { [ "path/to/export", "-D" ] }
+
+      it "enables debug" do
+        expect(command.debug?).to be(true)
+      end
+    end
+
+    context "when archive mode is set" do
+
+      let(:params) { [ "path/to/export", "-a" ] }
+
+      it "enables archiving the exported repo" do
+        expect(command.archive?).to be(true)
+      end
+
+      it "configures the export service to archive" do
+        expect(command.export_service.archive?).to be(true)
+      end
+    end
+
+    context "when the path to the exported repo is given" do
+
+      let(:params) { [ "path/to/export" ] }
+
+      it "configures the export service with the export path" do
+        expect(command.export_service.export_dir).to eq(File.expand_path("path/to/export"))
+      end
+
+      it "uses the default policyfile name" do
+        expect(command.export_service.policyfile_filename).to eq(File.expand_path("Policyfile.rb"))
+      end
+
+    end
+
+    context "when a Policyfile relative path and export path are given" do
+
+      let(:params) { [ "CustomNamedPolicy.rb", "path/to/export" ] }
+
+      it "configures the export service with the export path" do
+        expect(command.export_service.export_dir).to eq(File.expand_path("path/to/export"))
+      end
+
+      it "configures the export service with the policyfile relative path" do
+        expect(command.export_service.policyfile_filename).to eq(File.expand_path("CustomNamedPolicy.rb"))
+      end
+    end
+  end
+
+  describe "running the export" do
+
+    let(:params) { [ "/path/to/export" ] }
+
+    let(:ui) { TestHelpers::TestUI.new }
+
+    before do
+      command.ui = ui
+      allow(command).to receive(:export_service).and_return(export_service)
+    end
+
+    context "with no arguments" do
+
+      it "exits non-zero and prints a help message" do
+        expect(command.run).to eq(1)
+      end
+
+    end
+
+    context "when the command is successful" do
+
+      before do
+        expect(export_service).to receive(:run)
+      end
+
+      it "returns 0" do
+        expect(command.run(params)).to eq(0)
+      end
+
+      it "prints instructions for running chef-client in the repo" do
+        command.run(params)
+
+        expected_message = <<-MESSAGE
+To converge this system with the exported policy, run:
+  cd /path/to/export
+  chef-client -z
+MESSAGE
+        expect(ui.output).to include(expected_message)
+      end
+    end
+
+    context "when the command is unsuccessful" do
+
+      let(:backtrace) { caller[0...3] }
+
+      let(:cause) do
+        e = StandardError.new("some operation failed")
+        e.set_backtrace(backtrace)
+        e
+      end
+
+      let(:exception) do
+        ChefDK::PolicyfileExportRepoError.new("export failed", cause)
+      end
+
+      before do
+        expect(export_service).to receive(:run).and_raise(exception)
+      end
+
+      it "returns 1" do
+        expect(command.run(params)).to eq(1)
+      end
+
+      it "displays the exception and cause" do
+        expected_error_text = <<-E
+Error: export failed
+Reason: (StandardError) some operation failed
+
+E
+
+        command.run(params)
+        expect(ui.output).to eq(expected_error_text)
+      end
+
+      context "and debug is enabled" do
+
+        let(:params) { [ "path/to/export", "-D"] }
+
+        it "displays the exception and cause with backtrace" do
+          expected_error_text = <<-E
+Error: export failed
+Reason: (StandardError) some operation failed
+
+
+E
+
+          expected_error_text << backtrace.join("\n") << "\n"
+
+          command.run(params)
+          expect(ui.output).to eq(expected_error_text)
+        end
+      end
+
+    end
+
+  end
+end

data/spec/unit/command/generate_spec.rb

@@ -1,142 +1,142 @@
-#
-# Copyright:: Copyright (c) 2014 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 "stringio"
-require "chef-dk/command/generate"
-
-class ChefDK::Command::GeneratorCommands::Example < ChefDK::Command::GeneratorCommands::Base
-
-  option :one,
-    long:         "--option-one",
-    description:  "one"
-
-  option :two,
-    long:         "--option-two",
-    description:  "two"
-
-  option :arg,
-    short:        "-a ARG",
-    long:         "--arg ARG",
-    description:  "an option that takes an argument"
-
-  def initialize(argv)
-    super # required by mixlib-cli
-    @argv = argv
-  end
-
-  def run
-    parse_options(@argv)
-    { :argv => @argv, :ran_cmd => "example" }
-  end
-end
-
-describe ChefDK::Command::Generate do
-
-  # Use a subclass so we have a clean slate of defined generators
-  let(:generator_class) { Class.new(ChefDK::Command::Generate) }
-
-  let(:stdout_io) { StringIO.new }
-  let(:stderr_io) { StringIO.new }
-
-  def stdout
-    stdout_io.string
-  end
-
-  def stderr
-    stderr_io.string
-  end
-
-  subject(:generate) do
-    g = generator_class.new
-    allow(g).to receive(:stdout).and_return(stdout_io)
-    allow(g).to receive(:stderr).and_return(stderr_io)
-    g
-  end
-
-  it "has a list of generators" do
-    expect(generator_class.generators).to eq([])
-  end
-
-  context "with a generator defined" do
-    let(:expected_help_message) do
-      <<-E
-Usage: chef generate GENERATOR [options]
-
-Available generators:
-  example  this is a test
-E
-    end
-
-    before do
-      generator_class.generator(:example, :Example, "this is a test")
-    end
-
-    it "includes the generator in the list" do
-      expect(generator_class.generators.size).to eq(1)
-      generator_spec = generator_class.generators.first
-      expect(generator_spec.name).to eq(:example)
-      expect(generator_spec.class_name).to eq(:Example)
-      expect(generator_spec.description).to eq("this is a test")
-    end
-
-    it "includes the generator in the help output" do
-      expect(generator_class.banner).to eq(expected_help_message)
-    end
-
-    it "prints usage when running an unknown generator" do
-      generate.run(%w{ancient-aliens})
-      expect(stdout).to include(expected_help_message)
-    end
-
-    it "runs the generator sub-command" do
-      result = generate.run(%w{example})
-      expect(result[:ran_cmd]).to eq("example")
-    end
-
-    it "removes the subcommand name from argv" do
-      result = generate.run(%w{example})
-      expect(result[:argv]).to eq([])
-    end
-
-    it "passes extra arguments and options to the subcommand" do
-      result = generate.run(%w{example argument_one argument_two --option-one --option-two})
-      expect(result[:argv]).to eq(%w{argument_one argument_two --option-one --option-two})
-    end
-
-    describe "when an invalid option is passed to the subcommand" do
-
-      it "prints usage and returns non-zero" do
-        result = generate.run(%w{example --nope})
-        expect(result).to eq(1)
-        expect(stderr).to eq("ERROR: invalid option: --nope\n\n")
-      end
-
-    end
-
-    describe "when an option requires an argument but none is given" do
-
-      it "prints usage and returns non-zero" do
-        result = generate.run(%w{example --arg})
-        expect(result).to eq(1)
-        expect(stderr).to eq("ERROR: missing argument: --arg\n\n")
-      end
-
-    end
-
-  end
-end
+#
+# 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 "stringio"
+require "chef-dk/command/generate"
+
+class ChefDK::Command::GeneratorCommands::Example < ChefDK::Command::GeneratorCommands::Base
+
+  option :one,
+    long:         "--option-one",
+    description:  "one"
+
+  option :two,
+    long:         "--option-two",
+    description:  "two"
+
+  option :arg,
+    short:        "-a ARG",
+    long:         "--arg ARG",
+    description:  "an option that takes an argument"
+
+  def initialize(argv)
+    super # required by mixlib-cli
+    @argv = argv
+  end
+
+  def run
+    parse_options(@argv)
+    { :argv => @argv, :ran_cmd => "example" }
+  end
+end
+
+describe ChefDK::Command::Generate do
+
+  # Use a subclass so we have a clean slate of defined generators
+  let(:generator_class) { Class.new(ChefDK::Command::Generate) }
+
+  let(:stdout_io) { StringIO.new }
+  let(:stderr_io) { StringIO.new }
+
+  def stdout
+    stdout_io.string
+  end
+
+  def stderr
+    stderr_io.string
+  end
+
+  subject(:generate) do
+    g = generator_class.new
+    allow(g).to receive(:stdout).and_return(stdout_io)
+    allow(g).to receive(:stderr).and_return(stderr_io)
+    g
+  end
+
+  it "has a list of generators" do
+    expect(generator_class.generators).to eq([])
+  end
+
+  context "with a generator defined" do
+    let(:expected_help_message) do
+      <<-E
+Usage: chef generate GENERATOR [options]
+
+Available generators:
+  example  this is a test
+E
+    end
+
+    before do
+      generator_class.generator(:example, :Example, "this is a test")
+    end
+
+    it "includes the generator in the list" do
+      expect(generator_class.generators.size).to eq(1)
+      generator_spec = generator_class.generators.first
+      expect(generator_spec.name).to eq(:example)
+      expect(generator_spec.class_name).to eq(:Example)
+      expect(generator_spec.description).to eq("this is a test")
+    end
+
+    it "includes the generator in the help output" do
+      expect(generator_class.banner).to eq(expected_help_message)
+    end
+
+    it "prints usage when running an unknown generator" do
+      generate.run(%w{ancient-aliens})
+      expect(stdout).to include(expected_help_message)
+    end
+
+    it "runs the generator sub-command" do
+      result = generate.run(%w{example})
+      expect(result[:ran_cmd]).to eq("example")
+    end
+
+    it "removes the subcommand name from argv" do
+      result = generate.run(%w{example})
+      expect(result[:argv]).to eq([])
+    end
+
+    it "passes extra arguments and options to the subcommand" do
+      result = generate.run(%w{example argument_one argument_two --option-one --option-two})
+      expect(result[:argv]).to eq(%w{argument_one argument_two --option-one --option-two})
+    end
+
+    describe "when an invalid option is passed to the subcommand" do
+
+      it "prints usage and returns non-zero" do
+        result = generate.run(%w{example --nope})
+        expect(result).to eq(1)
+        expect(stderr).to eq("ERROR: invalid option: --nope\n\n")
+      end
+
+    end
+
+    describe "when an option requires an argument but none is given" do
+
+      it "prints usage and returns non-zero" do
+        result = generate.run(%w{example --arg})
+        expect(result).to eq(1)
+        expect(stderr).to eq("ERROR: missing argument: --arg\n\n")
+      end
+
+    end
+
+  end
+end