ceedling 1.1.10 → 1.2.1

data/spec/units/bin/cli_handler_spec.rb

@@ -0,0 +1,205 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+
+# bin/versionator.rb (pulled in transitively by cli_handler.rb) uses bare `require`
+# statements that only resolve when lib/ceedling/ and lib/ are directly on the load
+# path -- true in the real bin/ceedling bootstrap but not in this spec harness's
+# load path setup. Add the same directories here so `require 'cli_handler'` succeeds.
+here = File.dirname(__FILE__)
+$: << File.join(here, '../../../lib/ceedling')
+$: << File.join(here, '../../../lib')
+
+# cli_handler.rb requires 'mixins' before 'ceedling/constants', but bin/mixins.rb
+# references UNITY_ROOT_PATH, a constant only defined by ceedling/constants. The
+# real bin/ceedling bootstrap always loads ceedling/constants first, so this load
+# order only ever bites a spec harness requiring cli_handler.rb directly.
+require 'ceedling/constants'
+require 'cli_handler'
+require 'app_cfg'
+require 'path_validator'
+require 'cli_helper'
+require 'ceedling/ruby_expandinator'
+require 'ceedling/rake_app/rake_task_registry'
+
+# Most of CliHandler's public methods (build, dumpconfig, check, environment,
+# new_project, upgrade_project, create_example, list_rake_tasks) are thin
+# orchestration wiring together many already-independently-tested collaborators
+# in sequence. Unit testing those would mean mocking most of the collaborator
+# chain just to reach the one interesting line, producing brittle tests that
+# mirror the implementation rather than guard behavior -- they're exercised
+# end-to-end by system tests instead. Coverage here is scoped to methods with
+# real, self-contained branching logic: #inspect, #validate_string_param,
+# #version, #list_examples, and the private #standardize_project_and_mixins
+# helper (real collaborators, not doubles, since testing it meaningfully means
+# exercising the real filtering/standardizing behavior it coordinates).
+describe CliHandler do
+  before(:each) do
+    @loginator = double('loginator').as_null_object
+    @helper    = double('cli_helper').as_null_object
+
+    @cli_handler = described_class.new({
+      :composinator       => double('composinator').as_null_object,
+      :projectinator      => double('projectinator').as_null_object,
+      :cli_helper         => @helper,
+      :path_validator     => double('path_validator').as_null_object,
+      :rake_task_registry => double('rake_task_registry').as_null_object,
+      :actionator         => double('actionator').as_null_object,
+      :loginator          => @loginator,
+    })
+  end
+
+  describe '#inspect' do
+    it 'returns the class name instead of dumping instance variables' do
+      expect(@cli_handler.inspect).to eq('CliHandler')
+    end
+  end
+
+  describe '#validate_string_param' do
+    it 'raises a Thor::Error when the param equals the missing sentinel' do
+      expect {
+        @cli_handler.validate_string_param( 'MISSING', 'MISSING', '--project is missing a required filename parameter' )
+      }.to raise_error( Thor::Error, '--project is missing a required filename parameter' )
+    end
+
+    it 'does nothing when the param is a real value' do
+      expect {
+        @cli_handler.validate_string_param( 'project.yml', 'MISSING', 'unused message' )
+      }.to_not raise_error
+    end
+  end
+
+  describe '#version' do
+    before(:each) do
+      @app_cfg = CeedlingAppConfig.new
+    end
+
+    def fake_application_version(install_path)
+      double('application_versionator',
+        :ceedling_install_path => install_path,
+        :ceedling_build        => '1.2.0',
+        :cmock_tag             => '2.7.0',
+        :unity_tag             => '2.7.1',
+        :cexception_tag        => '1.3.4',
+      )
+    end
+
+    it 'renders a single Ceedling block when launcher and application share an install path' do
+      allow(@helper).to receive(:manufacture_app_version).and_return(
+        fake_application_version( @app_cfg[:ceedling_root_path] )
+      )
+
+      expect(@loginator).to receive(:console) do |message, _label|
+        expect(message).to include( 'Ceedling => 1.2.0' )
+        expect(message).to_not include( 'Ceedling Launcher' )
+        expect(message).to_not include( 'Ceedling App' )
+      end
+
+      @cli_handler.version( {}, @app_cfg )
+    end
+
+    it 'renders separate launcher and application blocks when their install paths differ' do
+      allow(@helper).to receive(:manufacture_app_version).and_return(
+        fake_application_version( '/somewhere/else/entirely' )
+      )
+
+      expect(@loginator).to receive(:console) do |message, _label|
+        # The launcher reports the version of the Ceedling running this spec
+        expect(message).to include( "Ceedling Launcher => #{Ceedling::Version::GEM}" )
+        expect(message).to include( 'Ceedling App => 1.2.0' )
+      end
+
+      @cli_handler.version( {}, @app_cfg )
+    end
+  end
+
+  describe '#list_examples' do
+    it 'raises when no example projects are found' do
+      allow(@helper).to receive(:lookup_example_projects).and_return( [] )
+
+      expect {
+        @cli_handler.list_examples( {}, CeedlingAppConfig.new, {} )
+      }.to raise_error( 'No examples projects found' )
+    end
+
+    it 'lists each example project found' do
+      allow(@helper).to receive(:lookup_example_projects).and_return( ['blinky', 'temp_sensor'] )
+
+      # #list_examples logs the listing and a separate documentation pointer --
+      # collect every console call rather than assume a single message.
+      messages = []
+      allow(@loginator).to receive(:console) {|message, _label| messages << message }
+
+      @cli_handler.list_examples( {}, CeedlingAppConfig.new, {} )
+
+      listing = messages.join
+      expect(listing).to include( 'blinky' )
+      expect(listing).to include( 'temp_sensor' )
+    end
+  end
+
+  describe '#standardize_project_and_mixins (private)' do
+    before(:each) do
+      real_path_validator = PathValidator.new({
+        :file_wrapper => double('file_wrapper').as_null_object,
+        :loginator    => double('loginator').as_null_object,
+      })
+      real_cli_helper = CliHelper.new({
+        :file_wrapper       => double('file_wrapper').as_null_object,
+        :actionator         => double('actionator').as_null_object,
+        :config_walkinator  => double('config_walkinator').as_null_object,
+        :path_validator     => real_path_validator,
+        :rake_task_registry => double('rake_task_registry').as_null_object,
+        :loginator          => double('loginator').as_null_object,
+        :reportinator       => double('reportinator').as_null_object,
+        :system_wrapper     => double('system_wrapper').as_null_object,
+        :ruby_expandinator  => RubyExpandinator.new,
+      })
+
+      @cli_handler_real = described_class.new({
+        :composinator       => double('composinator').as_null_object,
+        :projectinator      => double('projectinator').as_null_object,
+        :cli_helper         => real_cli_helper,
+        :path_validator     => real_path_validator,
+        :rake_task_registry => double('rake_task_registry').as_null_object,
+        :actionator         => double('actionator').as_null_object,
+        :loginator          => double('loginator').as_null_object,
+      })
+    end
+
+    def standardize(project, mixins)
+      @cli_handler_real.send( :standardize_project_and_mixins, project, mixins )
+    end
+
+    it 'standardizes backslashes in the project path' do
+      project, _mixins = standardize( 'some\\project.yml', [] )
+
+      expect(project).to eq( 'some/project.yml' )
+    end
+
+    it 'standardizes filepath/name mixin entries but leaves inline YAML entries untouched' do
+      inline_yaml = "=:project:\n  :build_root: some\\path"
+
+      _project, mixins = standardize( nil, ['mixin\\dir\\clang.yml', inline_yaml] )
+
+      expect(mixins).to eq( ['mixin/dir/clang.yml', inline_yaml] )
+    end
+
+    it 'standardizes each occurrence of a repeated mixin value independently' do
+      _project, mixins = standardize( nil, ['dup\\path.yml', 'other\\path.yml', 'dup\\path.yml'] )
+
+      expect(mixins).to eq( ['dup/path.yml', 'other/path.yml', 'dup/path.yml'] )
+    end
+
+    it 'passes a nil project through unchanged' do
+      project, _mixins = standardize( nil, [] )
+
+      expect(project).to be_nil
+    end
+  end
+end

data/spec/units/bin/cli_helper_spec.rb

@@ -6,6 +6,8 @@
 # =========================================================================
 
 require 'spec_helper'
+require 'tmpdir'
+require 'rake'
 
 # bin/versionator.rb (pulled in transitively by cli_helper.rb) uses bare `require`
 # statements (`require 'exceptions'`, `require 'constants'`, `require 'version'`)
@@ -18,22 +20,30 @@ $: << File.join(here, '../../../lib/ceedling')
 $: << File.join(here, '../../../lib')
 
 require 'cli_helper'
+require 'app_cfg'
 require 'ceedling/ruby_expandinator'
+# CliHelper#test_task? references RakeTaskRegistry::TAG_TEST, but only
+# bin/cli_handler.rb requires this file in the real bootstrap (loaded before
+# cli_helper.rb's methods are ever called) -- required directly here since this
+# spec exercises CliHelper in isolation.
+require 'ceedling/rake_app/rake_task_registry'
 
-# Scoped narrowly to #set_ruby_replacement, the new --ruby-replacement CLI flag
-# wiring. Broader CliHelper coverage is a pre-existing gap outside this feature's
-# scope (no spec file existed for this class before this feature).
 describe CliHelper do
   before(:each) do
-    @ruby_expandinator = RubyExpandinator.new
+    @ruby_expandinator  = RubyExpandinator.new
+    @rake_task_registry = double('rake_task_registry').as_null_object
+    @file_wrapper       = double('file_wrapper').as_null_object
+    @config_walkinator  = double('config_walkinator').as_null_object
+    @path_validator     = double('path_validator').as_null_object
+    @loginator          = double('loginator').as_null_object
 
     @cli_helper = described_class.new({
-      :file_wrapper       => double('file_wrapper').as_null_object,
-      :actions_wrapper    => double('actions_wrapper').as_null_object,
-      :config_walkinator  => double('config_walkinator').as_null_object,
-      :path_validator     => double('path_validator').as_null_object,
-      :rake_task_registry => double('rake_task_registry').as_null_object,
-      :loginator          => double('loginator').as_null_object,
+      :file_wrapper       => @file_wrapper,
+      :actionator         => double('actionator').as_null_object,
+      :config_walkinator  => @config_walkinator,
+      :path_validator     => @path_validator,
+      :rake_task_registry => @rake_task_registry,
+      :loginator          => @loginator,
       :reportinator       => double('reportinator').as_null_object,
       :system_wrapper     => double('system_wrapper').as_null_object,
       :ruby_expandinator  => @ruby_expandinator,
@@ -66,4 +76,232 @@ describe CliHelper do
       expect(@ruby_expandinator.enabled?).to eq(true)
     end
   end
+
+  describe '#process_force_test_rerun' do
+    it 'does nothing when the flag is false, without even consulting the task registry' do
+      expect(@rake_task_registry).to_not receive(:task_is?)
+
+      expect {
+        @cli_helper.process_force_test_rerun( force_test_rerun: false, tasks: [], default_tasks: [] )
+      }.to_not raise_error
+    end
+
+    it 'raises when the flag is true and no test task is present in tasks or default_tasks' do
+      allow(@rake_task_registry).to receive(:task_is?).and_return( false )
+
+      expect {
+        @cli_helper.process_force_test_rerun( force_test_rerun: true, tasks: ['release'], default_tasks: ['test:all'] )
+      }.to raise_error( CeedlingException, /only applicable to test tasks/ )
+    end
+
+    it 'does not raise when the flag is true and a test task is present in tasks' do
+      allow(@rake_task_registry).to receive(:task_is?).with( 'test:all', RakeTaskRegistry::TAG_TEST ).and_return( true )
+
+      expect {
+        @cli_helper.process_force_test_rerun( force_test_rerun: true, tasks: ['test:all'], default_tasks: [] )
+      }.to_not raise_error
+    end
+
+    it 'does not raise when the flag is true, tasks is empty, and a test task is present in default_tasks' do
+      allow(@rake_task_registry).to receive(:task_is?).with( 'test:all', RakeTaskRegistry::TAG_TEST ).and_return( true )
+
+      expect {
+        @cli_helper.process_force_test_rerun( force_test_rerun: true, tasks: [], default_tasks: ['test:all'] )
+      }.to_not raise_error
+    end
+  end
+
+  # Whether a command's tasks build a release decides what build/vendor needs (GH #1361)
+  describe '#release_task?' do
+    it 'is true when any task belongs to a release-building namespace' do
+      allow(@rake_task_registry).to receive(:task_is?) { |task, tag| task == 'release' && tag == RakeTaskRegistry::TAG_RELEASE }
+
+      expect( @cli_helper.release_task?( tasks: ['test:all', 'release'] ) ).to be(true)
+      expect( @cli_helper.release_task?( tasks: ['test:all', 'files:test'] ) ).to be(false)
+    end
+  end
+
+  describe '#which_ceedling?' do
+    before(:each) do
+      @app_cfg = CeedlingAppConfig.new
+      # Baseline: no :project ↳ :which_ceedling entry found. Tests exercising that
+      # config path override this with a more specific `.with(...)` stub below.
+      allow(@config_walkinator).to receive(:fetch_value).and_return( [nil, nil] )
+    end
+
+    it 'uses the WHICH_CEEDLING environment variable at highest priority' do
+      which, path = @cli_helper.which_ceedling?( env: {'WHICH_CEEDLING' => 'gem'}, app_cfg: @app_cfg )
+
+      expect(which).to eq( :gem )
+      expect(path).to eq( @app_cfg[:ceedling_rakefile_filepath] )
+    end
+
+    it 'falls back to config :project ↳ :which_ceedling when no environment variable is set' do
+      config = {:project => {:which_ceedling => 'gem'}}
+      allow(@config_walkinator).to receive(:fetch_value).with( :project, :which_ceedling, hash: config ).and_return( ['gem', nil] )
+
+      which, path = @cli_helper.which_ceedling?( env: {}, config: config, app_cfg: @app_cfg )
+
+      expect(which).to eq( :gem )
+      expect(path).to eq( @app_cfg[:ceedling_rakefile_filepath] )
+    end
+
+    it 'falls back to a vendor/ceedling directory when neither environment nor config specify anything' do
+      allow(@file_wrapper).to receive(:directory?).with( 'vendor/ceedling' ).and_return( true )
+      allow(@file_wrapper).to receive(:exist?).and_return( true )
+
+      which, path = @cli_helper.which_ceedling?( env: {}, app_cfg: @app_cfg )
+
+      expect(which).to eq( :path )
+      expect(path).to eq( @app_cfg[:ceedling_rakefile_filepath] )
+      expect(@app_cfg[:ceedling_root_path]).to eq( File.expand_path('vendor/ceedling') )
+    end
+
+    it 'defaults to :gem when nothing is set and no vendor/ceedling directory exists' do
+      allow(@file_wrapper).to receive(:directory?).with( 'vendor/ceedling' ).and_return( false )
+
+      which, path = @cli_helper.which_ceedling?( env: {}, app_cfg: @app_cfg )
+
+      expect(which).to eq( :gem )
+      expect(path).to eq( @app_cfg[:ceedling_rakefile_filepath] )
+    end
+
+    it 'raises when a configured launch path does not exist as a directory' do
+      config = {:project => {:which_ceedling => 'nonexistent/path'}}
+      allow(@config_walkinator).to receive(:fetch_value).with( :project, :which_ceedling, hash: config ).and_return( ['nonexistent/path', nil] )
+      allow(@file_wrapper).to receive(:directory?).and_return( false )
+
+      expect {
+        @cli_helper.which_ceedling?( env: {}, config: config, app_cfg: @app_cfg )
+      }.to raise_error( /does not exist/ )
+    end
+
+    it 'raises when a configured launch path exists but contains no Ceedling installation' do
+      config = {:project => {:which_ceedling => 'empty/path'}}
+      allow(@config_walkinator).to receive(:fetch_value).with( :project, :which_ceedling, hash: config ).and_return( ['empty/path', nil] )
+      allow(@file_wrapper).to receive(:directory?).and_return( true )
+      allow(@file_wrapper).to receive(:exist?).and_return( false )
+
+      expect {
+        @cli_helper.which_ceedling?( env: {}, config: config, app_cfg: @app_cfg )
+      }.to raise_error( /contains no Ceedling installation/ )
+    end
+  end
+
+  describe '#set_verbosity' do
+    after(:each) do
+      # These globals are frozen once set -- clear them so later specs in the
+      # same process (unit suite runs as one process) start from a clean slate.
+      Object.send(:remove_const, 'PROJECT_VERBOSITY') if Object.const_defined?('PROJECT_VERBOSITY')
+      Object.send(:remove_const, 'PROJECT_DEBUG') if Object.const_defined?('PROJECT_DEBUG')
+    end
+
+    it 'defaults to Verbosity::NORMAL when given nil' do
+      expect(@cli_helper.set_verbosity( nil )).to eq( Verbosity::NORMAL )
+      expect(PROJECT_VERBOSITY).to eq( Verbosity::NORMAL )
+      expect(PROJECT_DEBUG).to eq( false )
+    end
+
+    it 'passes an Integer verbosity constant through directly' do
+      expect(@cli_helper.set_verbosity( Verbosity::OBNOXIOUS )).to eq( Verbosity::OBNOXIOUS )
+    end
+
+    it 'parses a numeric string as an integer verbosity level' do
+      expect(@cli_helper.set_verbosity( '4' )).to eq( 4 )
+    end
+
+    it 'looks up a named verbosity string' do
+      expect(@cli_helper.set_verbosity( 'debug' )).to eq( Verbosity::DEBUG )
+      expect(PROJECT_DEBUG).to eq( true )
+    end
+
+    it 'raises for an unrecognized named verbosity' do
+      expect { @cli_helper.set_verbosity( 'not-a-real-level' ) }.to raise_error( /Unkown Verbosity/ )
+    end
+
+    it 'is idempotent once established unless override is true' do
+      @cli_helper.set_verbosity( Verbosity::DEBUG )
+
+      expect(@cli_helper.set_verbosity( Verbosity::NORMAL, override: false )).to eq( Verbosity::DEBUG )
+    end
+
+    it 'reconfigures when override is true, the default' do
+      @cli_helper.set_verbosity( Verbosity::DEBUG )
+
+      expect(@cli_helper.set_verbosity( Verbosity::NORMAL )).to eq( Verbosity::NORMAL )
+    end
+  end
+
+  describe '#process_log_filepath' do
+    around(:each) do |example|
+      Dir.mktmpdir do |dir|
+        @tmpdir = dir
+        example.run
+      end
+    end
+
+    it 'returns an empty string when logging is explicitly disabled' do
+      result = @cli_helper.process_log_filepath( @tmpdir, false, 'ignored.log' )
+
+      expect(result).to eq( '' )
+    end
+
+    it 'returns an empty string when neither --log nor --logfile is set' do
+      result = @cli_helper.process_log_filepath( @tmpdir, nil, '' )
+
+      expect(result).to eq( '' )
+    end
+
+    it 'uses the explicit --logfile path when one is given, creating its directory' do
+      logfile = File.join( @tmpdir, 'nested', 'custom.log' )
+      expect(@file_wrapper).to receive(:mkdir).with( File.join( @tmpdir, 'nested' ) )
+
+      result = @cli_helper.process_log_filepath( @tmpdir, nil, logfile )
+
+      expect(result).to eq( File.expand_path( logfile ) )
+    end
+
+    it 'falls back to the default logfile path under logging_path when --log is enabled with no --logfile' do
+      # @tmpdir itself already exists, so no mkdir call is expected here.
+      expect(@file_wrapper).to_not receive(:mkdir)
+
+      result = @cli_helper.process_log_filepath( @tmpdir, true, '' )
+
+      expect(result).to eq( File.expand_path( File.join( @tmpdir, DEFAULT_CEEDLING_LOGFILE ) ) )
+    end
+  end
+
+  describe '#run_rake_tasks' do
+    before(:each) do
+      @rake_application = double('rake_application')
+      allow(Rake).to receive(:application).and_return( @rake_application )
+    end
+
+    it 'raises a friendlier CeedlingException when Rake reports an unrecognized task' do
+      allow(@rake_application).to receive(:collect_command_line_tasks).with( ['bogus:task'] )
+      allow(@rake_application).to receive(:top_level).and_raise(
+        RuntimeError.new("Don't know how to build task 'bogus:task' (See the list of available tasks with `rake --tasks`)")
+      )
+
+      expect {
+        @cli_helper.run_rake_tasks( ['bogus:task'] )
+      }.to raise_error( CeedlingException, /Unrecognized build task 'bogus:task'/ )
+    end
+
+    it 're-raises RuntimeErrors unrelated to an unrecognized task unchanged' do
+      allow(@rake_application).to receive(:collect_command_line_tasks)
+      allow(@rake_application).to receive(:top_level).and_raise( RuntimeError.new('Something else entirely went wrong') )
+
+      expect {
+        @cli_helper.run_rake_tasks( ['test:all'] )
+      }.to raise_error( RuntimeError, 'Something else entirely went wrong' )
+    end
+
+    it 'does not raise when Rake completes normally' do
+      allow(@rake_application).to receive(:collect_command_line_tasks)
+      allow(@rake_application).to receive(:top_level)
+
+      expect { @cli_helper.run_rake_tasks( ['test:all'] ) }.to_not raise_error
+    end
+  end
 end

data/spec/units/bin/cli_options_transform_spec.rb

@@ -0,0 +1,49 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/constants'
+require 'cli_options_transform'
+
+# Plain hashes stand in for Thor's options -- this module has no Thor
+# dependency, matching the posture that CLI logic worth testing in isolation
+# should be extractable from Thor configuration itself.
+describe CliOptionsTransform do
+  describe '.apply_debug_flag' do
+    it 'forces Verbosity::DEBUG when the hidden --debug flag is set' do
+      options = { debug: true, verbosity: Verbosity::NORMAL }
+
+      result = described_class.apply_debug_flag( options )
+
+      expect(result[:verbosity]).to eq( Verbosity::DEBUG )
+    end
+
+    it 'leaves an already-set :verbosity untouched when --debug is not set' do
+      options = { debug: false, verbosity: Verbosity::OBNOXIOUS }
+
+      result = described_class.apply_debug_flag( options )
+
+      expect(result[:verbosity]).to eq( Verbosity::OBNOXIOUS )
+    end
+
+    it 'leaves a missing :verbosity as nil when --debug is not set' do
+      options = { debug: false }
+
+      result = described_class.apply_debug_flag( options )
+
+      expect(result[:verbosity]).to be_nil
+    end
+
+    it 'returns the same Hash it was given' do
+      options = { debug: false }
+
+      result = described_class.apply_debug_flag( options )
+
+      expect(result).to equal( options )
+    end
+  end
+end