(GH-808) Implement pdk release prep and publish subcommands

Previously the pdk release command was added.  This commit adds the prep and
publish subcommands as per PDK RFC 003.

This commit also adds tests for new subcommands.

lib/pdk/cli/release.rb

@@ -37,15 +37,23 @@ module PDK::CLI
         log_level: :info,
       )
 
-      unless opts[:force]
-        Release.prepare_interview(opts)
-      end
+      Release.prepare_interview(opts) unless opts[:force]
 
-      # Don't pass tokens to analytics
-      PDK::CLI::Util.analytics_screen_view('release', opts.reject { |k, _| k == :'forge-token' })
+      Release.send_analytics('release', opts)
 
       release = PDK::Module::Release.new(nil, opts)
 
+      Release.module_compatibility_checks!(release, opts)
+
+      release.run
+    end
+  end
+
+  module Release
+    # Checks whether the module is compatible with PDK release process
+    # @param release PDK::Module::Release Object representing the release
+    # @param opts Options Hash from Cri
+    def self.module_compatibility_checks!(release, opts)
       unless release.module_metadata.forge_ready?
         if opts[:force]
           PDK.logger.warn _(
@@ -60,7 +68,7 @@ module PDK::CLI
         end
       end
 
-      unless release.pdk_compatible?
+      unless release.pdk_compatible? # rubocop:disable Style/GuardClause Nope!
         if opts[:force]
           PDK.logger.warn _('This module is not compatible with PDK, so PDK can not validate or test this build.')
         else
@@ -73,12 +81,14 @@ module PDK::CLI
           end
         end
       end
+    end
 
-      release.run
+    # Send_analytics for the given command and Cri options
+    def self.send_analytics(command, opts)
+      # Don't pass tokens to analytics
+      PDK::CLI::Util.analytics_screen_view(command, opts.reject { |k, _| k == :'forge-token' })
     end
-  end
 
-  module Release
     def self.prepare_interview(opts)
       questions = []
 
@@ -177,3 +187,6 @@ def self.prepare_publish_interview(prompt, opts)
     end
   end
 end
+
+require 'pdk/cli/release/prep'
+require 'pdk/cli/release/publish'

lib/pdk/cli/release/prep.rb

@@ -0,0 +1,39 @@
+require 'pdk/cli/release'
+
+module PDK::CLI
+  @release_prep_cmd = @release_cmd.define_command do
+    name 'prep'
+    usage _('prep [options]')
+    summary _('(Experimental) Performs all the pre-release checks to ensure module is ready to be released')
+
+    flag nil, :force,                _('Prepare the module automatically, with no prompts.')
+    flag nil, :'skip-validation',    _('Skips the module validation check.')
+    flag nil, :'skip-changelog',     _('Skips the automatic changelog generation.')
+    flag nil, :'skip-dependency',    _('Skips the module dependency check.')
+    flag nil, :'skip-documentation', _('Skips the documentation update.')
+
+    option nil, :version, _('Update the module to the specified version prior to release. When not specified, the new version will be computed from the Changelog where possible.'),
+           argument: :required
+
+    run do |opts, _args, cmd|
+      # Make sure build is being run in a valid module directory with a metadata.json
+      PDK::CLI::Util.ensure_in_module!(
+        message:   _("`pdk release #{cmd.name}` can only be run from inside a valid module with a metadata.json."),
+        log_level: :info,
+      )
+
+      opts[:'skip-build'] = true
+      opts[:'skip-publish'] = true
+
+      Release.prepare_interview(opts) unless opts[:force]
+
+      Release.send_analytics("release #{cmd.name}", opts)
+
+      release = PDK::Module::Release.new(nil, opts)
+
+      Release.module_compatibility_checks!(release, opts)
+
+      release.run
+    end
+  end
+end

lib/pdk/cli/release/publish.rb

@@ -0,0 +1,40 @@
+require 'pdk/cli/release'
+
+module PDK::CLI
+  @release_publish_cmd = @release_cmd.define_command do
+    name 'publish'
+    usage _('publish [options] <tarball>')
+    summary _('(Experimental) Publishes the module <tarball> to the Forge.')
+
+    flag nil, :force,                _('Publish the module automatically, with no prompts.')
+
+    option nil, :'forge-upload-url', _('Set forge upload url path.'),
+           argument: :required, default: 'https://forgeapi.puppetlabs.com/v3/releases'
+
+    option nil, :'forge-token', _('Set Forge API token.'), argument: :required, default: nil
+
+    run do |opts, _args, cmd|
+      # Make sure build is being run in a valid module directory with a metadata.json
+      PDK::CLI::Util.ensure_in_module!(
+        message:   _("`pdk release #{cmd.name}` can only be run from inside a valid module with a metadata.json."),
+        log_level: :info,
+      )
+
+      opts[:'skip-validation'] = true
+      opts[:'skip-changelog'] = true
+      opts[:'skip-dependency'] = true
+      opts[:'skip-documentation'] = true
+      opts[:'skip-build'] = true
+      opts[:'skip-versionset'] = true
+      opts[:force] = true unless PDK::CLI::Util.interactive?
+
+      Release.prepare_publish_interview(TTY::Prompt.new(help_color: :cyan), opts) unless opts[:force]
+
+      Release.send_analytics("release #{cmd.name}", opts)
+
+      release = PDK::Module::Release.new(nil, opts)
+
+      release.run
+    end
+  end
+end

spec/unit/pdk/cli/release/prep_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'pdk/cli'
+
+describe 'PDK::CLI release prep' do
+  let(:help_text) { a_string_matching(%r{^USAGE\s+pdk release prep}m) }
+  let(:cli_args) { %w[release prep] }
+
+  context 'when not run from inside a module' do
+    include_context 'run outside module'
+
+    it 'exits with an error' do
+      expect(logger).to receive(:error).with(a_string_matching(%r{must be run from inside a valid module}))
+
+      expect { PDK::CLI.run(cli_args) }.to exit_nonzero
+    end
+
+    it 'does not submit the command to analytics' do
+      expect(analytics).not_to receive(:screen_view)
+
+      expect { PDK::CLI.run(cli_args) }.to exit_nonzero
+    end
+  end
+
+  context 'when run from inside a module' do
+    let(:release_object) do
+      instance_double(
+        PDK::Module::Release,
+        pdk_compatible?: true,
+        module_metadata: mock_metadata_obj,
+        run: nil,
+      )
+    end
+
+    let(:mock_metadata_obj) do
+      instance_double(
+        PDK::Module::Metadata,
+        forge_ready?: true,
+      )
+    end
+
+    before(:each) do
+      allow(PDK::CLI::Util).to receive(:ensure_in_module!).and_return(nil)
+      allow(PDK::Module::Release).to receive(:new).and_return(release_object)
+      allow(PDK::Util).to receive(:exit_process).and_raise('exit_process mock should not be called')
+    end
+
+    it 'calls PDK::Module::Release.run' do
+      expect(release_object).to receive(:run)
+
+      expect { PDK::CLI.run(cli_args.concat(%w[--force])) }.not_to raise_error
+    end
+
+    it 'skips building and publishing' do
+      expect(PDK::Module::Release).to receive(:new).with(Object, hash_including(:'skip-build' => true, :'skip-publish' => true))
+
+      expect { PDK::CLI.run(cli_args.concat(%w[--force])) }.not_to raise_error
+    end
+
+    it 'does not start an interview when --force is used' do
+      expect(PDK::CLI::Util::Interview).to receive(:new).never
+
+      PDK::CLI.run(cli_args.concat(%w[--force]))
+    end
+
+    it 'calls PDK::CLI::Release.module_compatibility_checks!' do
+      expect(PDK::CLI::Release).to receive(:module_compatibility_checks!).and_return(nil)
+
+      expect { PDK::CLI.run(cli_args.concat(%w[--force])) }.not_to raise_error
+    end
+  end
+end

spec/unit/pdk/cli/release/publish_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'pdk/cli'
+
+describe 'PDK::CLI release publish' do
+  let(:help_text) { a_string_matching(%r{^USAGE\s+pdk release publish}m) }
+  let(:cli_args) { %w[release publish] }
+
+  context 'when not run from inside a module' do
+    include_context 'run outside module'
+
+    it 'exits with an error' do
+      expect(logger).to receive(:error).with(a_string_matching(%r{must be run from inside a valid module}))
+
+      expect { PDK::CLI.run(cli_args) }.to exit_nonzero
+    end
+
+    it 'does not submit the command to analytics' do
+      expect(analytics).not_to receive(:screen_view)
+
+      expect { PDK::CLI.run(cli_args) }.to exit_nonzero
+    end
+  end
+
+  context 'when run from inside a module' do
+    let(:release_object) do
+      instance_double(
+        PDK::Module::Release,
+        pdk_compatible?: true,
+        module_metadata: mock_metadata_obj,
+        run: nil,
+      )
+    end
+
+    let(:mock_metadata_obj) do
+      instance_double(
+        PDK::Module::Metadata,
+        forge_ready?: true,
+      )
+    end
+
+    before(:each) do
+      allow(PDK::CLI::Util).to receive(:ensure_in_module!).and_return(nil)
+      allow(PDK::Module::Release).to receive(:new).and_return(release_object)
+      allow(PDK::Util).to receive(:exit_process).and_raise('exit_process mock should not be called')
+    end
+
+    it 'calls PDK::Module::Release.run' do
+      expect(release_object).to receive(:run)
+
+      expect { PDK::CLI.run(cli_args.concat(%w[--force])) }.not_to raise_error
+    end
+
+    it 'skips all but publishing' do
+      expect(PDK::Module::Release).to receive(:new).with(
+        Object,
+        hash_including(
+          :'skip-validation'    => true,
+          :'skip-changelog'     => true,
+          :'skip-dependency'    => true,
+          :'skip-documentation' => true,
+          :'skip-build'         => true,
+        ),
+      )
+
+      expect { PDK::CLI.run(cli_args.concat(%w[--force])) }.not_to raise_error
+    end
+
+    it 'does not start an interview when --force is used' do
+      expect(PDK::CLI::Util::Interview).to receive(:new).never
+
+      PDK::CLI.run(cli_args.concat(%w[--force]))
+    end
+
+    it 'implicitly uses --force in non-interactive environments' do
+      allow(PDK::CLI::Util).to receive(:interactive?).and_return(false)
+      expect(PDK::Module::Release).to receive(:new).with(Object, hash_including(force: true))
+
+      expect { PDK::CLI.run(cli_args) }.not_to raise_error
+    end
+  end
+end

spec/unit/pdk/cli/release_spec.rb

@@ -2,8 +2,6 @@
 require 'pdk/cli'
 
 describe 'PDK::CLI release' do
-  let(:help_text) { a_string_matching(%r{^USAGE\s+pdk release}m) }
-
   context 'when not run from inside a module' do
     include_context 'run outside module'
 
@@ -19,6 +17,7 @@
         PDK::Module::Release,
         pdk_compatible?: true,
         module_metadata: mock_metadata_obj,
+        run: nil,
       )
     end
 
@@ -33,11 +32,68 @@
       allow(PDK::CLI::Util).to receive(:ensure_in_module!).and_return(nil)
       allow(PDK::Module::Release).to receive(:new).and_return(release_object)
       allow(PDK::Util).to receive(:exit_process).and_raise('exit_process mock should not be called')
-      expect(release_object).to receive(:run).and_return(nil)
     end
 
     it 'calls PDK::Module::Release.run' do
+      expect(release_object).to receive(:run).and_return(nil)
+
       expect { PDK::CLI.run(%w[release --force]) }.not_to raise_error
     end
+
+    it 'does not start an interview when --force is used' do
+      expect(PDK::CLI::Util::Interview).to receive(:new).never
+
+      PDK::CLI.run(%w[release --force])
+    end
+
+    it 'calls PDK::CLI::Release.module_compatibility_checks!' do
+      expect(PDK::CLI::Release).to receive(:module_compatibility_checks!).and_return(nil)
+
+      expect { PDK::CLI.run(%w[release --force]) }.not_to raise_error
+    end
+  end
+
+  describe '#module_compatibility_checks!' do
+    let(:release_object) do
+      instance_double(
+        PDK::Module::Release,
+        pdk_compatible?: true,
+        module_metadata: mock_metadata_obj,
+        run: nil,
+      )
+    end
+
+    let(:mock_metadata_obj) do
+      instance_double(
+        PDK::Module::Metadata,
+        forge_ready?: true,
+      )
+    end
+
+    let(:opts) { { force: true } }
+    let(:release) { PDK::CLI::Release }
+
+    context 'With a module that is not forge ready' do
+      before(:each) do
+        allow(mock_metadata_obj).to receive(:forge_ready?).and_return(false)
+        allow(mock_metadata_obj).to receive(:missing_fields).and_return(['mock_field'])
+      end
+
+      it 'raises a warning' do
+        expect(PDK.logger).to receive(:warn).with(%r{mock_field})
+        release.module_compatibility_checks!(release_object, opts)
+      end
+    end
+
+    context 'With a module that is not pdk compatibler' do
+      before(:each) do
+        allow(release_object).to receive(:pdk_compatible?).and_return(false)
+      end
+
+      it 'raises a warning' do
+        expect(PDK.logger).to receive(:warn).with(%r{not compatible with PDK})
+        release.module_compatibility_checks!(release_object, opts)
+      end
+    end
   end
 end