ceedling 1.2.0 → 1.2.1

data/spec/integration/vendor_copy_transient_io_retry_spec.rb

@@ -5,44 +5,37 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
-# Integration coverage for Issue #1292: a vendor destination (build/vendor/unity/src,
-# etc.) occasionally turns up as the wrong file/directory type mid-copy, crashing with
-# Errno::ENOTDIR/EISDIR. Does FileWrapper#cp_r_with_retry actually let
-# ConfiguratorSetup#vendor_frameworks_and_support_files ride out a transient fault of
-# that shape, end to end against a real filesystem -- and does a fault that never
-# clears still surface as a clear, path-naming CeedlingException rather than a raw Errno?
+# ConfiguratorSetup#vendor_frameworks_and_support_files with a real FileWrapper on a real
+# filesystem. A build brings build/vendor up to date with the gem's frameworks. It writes only
+# a file that differs from its source, and replaces it whole by renaming a temporary copy over
+# it, so a concurrent build never reads a half-written header (GH #1361). A transient copy
+# fault, such as a path briefly the wrong type (GH #1292), is retried, and one that never
+# clears names the destination.
 #
-# Modeled directly on spec/integration/preprocessing_transient_io_retry_spec.rb: a real
-# ConfiguratorSetup + real FileWrapper subclass that controls exactly one #cp_r call
-# (matched by destination path) so the fault is deterministic. Faulting at #cp_r rather
-# than #cp_r_with_retry itself matters here -- cp_r_with_retry's own retry loop (already
-# proven exhaustively in file_wrapper_spec.rb) is exactly the mechanism this spec needs
-# to actually run.
+# Faults are injected at FileWrapper#replace_file, the one write of each file, so the retry
+# loop in FileWrapper#sync_tree is what runs.
 
 require 'spec_helper'
 require 'spec_integration_helper'
 require 'ceedling/config/configurator_setup'
 require 'ceedling/constants'
 
-describe 'Vendor-copy transient I/O retry (integration)' do
+describe 'Vendor copy into build/vendor (integration)' do
   include IntegrationSpecHelpers
 
-  # A real FileWrapper whose #cp_r raises for `fault_dest` the first `raises_left`
-  # times it's called, then behaves normally -- every other destination is untouched.
-  # Real FileWrapper#cp_r_with_retry (inherited, not overridden) is what actually retries.
-  # Named distinctly from preprocessing_transient_io_retry_spec.rb's own FaultingFileWrapper
-  # -- both are top-level classes loaded into the same RSpec process, and Ruby's open
-  # classes would otherwise let the second file's definition silently clobber the first's.
-  class CpRFaultingFileWrapper < FileWrapper
-    def initialize(fault_dest:, raises_left: 1, error: Errno::EISDIR, **kwargs)
+  # A real FileWrapper whose #replace_file raises for files beneath `fault_dir` the first
+  # `raises_left` times. Named apart from other specs' faulting wrappers, since top-level
+  # classes share one RSpec process.
+  class ReplaceFaultingFileWrapper < FileWrapper
+    def initialize(fault_dir:, raises_left: 1, error: Errno::EISDIR, **kwargs)
       super(**kwargs)
-      @fault_dest = fault_dest
+      @fault_dir = fault_dir
       @raises_left = raises_left
       @error = error
     end
 
-    def cp_r(source, destination, options={})
-      if destination == @fault_dest && @raises_left > 0
+    def replace_file(source, destination)
+      if destination.start_with?( @fault_dir ) && @raises_left > 0
         @raises_left -= 1
         raise @error, "simulated transient type-mismatch on #{destination}"
       end
@@ -50,81 +43,136 @@ describe 'Vendor-copy transient I/O retry (integration)' do
     end
   end
 
-  # Real ConfiguratorSetup wired to `file_wrapper`; every other collaborator is
-  # untouched by #vendor_frameworks_and_support_files, so NULL stands in for them.
+  def file_wrapper(**fault)
+    options = { loginator: IntegrationSpecHelpers::NULL, verbosinator: IntegrationSpecHelpers::NULL }
+    return fault.empty? ? FileWrapper.new( options ) : ReplaceFaultingFileWrapper.new( **fault, **options )
+  end
+
   def build_configurator_setup(file_wrapper)
     ConfiguratorSetup.new(
       configurator_builder:   IntegrationSpecHelpers::NULL,
       configurator_validator: IntegrationSpecHelpers::NULL,
-      loginator:               IntegrationSpecHelpers::NULL,
-      reportinator:            IntegrationSpecHelpers::NULL,
-      file_wrapper:            file_wrapper,
-      system_wrapper:          IntegrationSpecHelpers::NULL,
-      tool_executor:           IntegrationSpecHelpers::NULL
+      loginator:              IntegrationSpecHelpers::NULL,
+      reportinator:           IntegrationSpecHelpers::NULL,
+      file_wrapper:           file_wrapper,
+      system_wrapper:         IntegrationSpecHelpers::NULL,
+      tool_executor:          IntegrationSpecHelpers::NULL
     )
   end
 
-  # A minimal but real fixture standing in for the gem's own vendor/unity/src -- one
-  # real file, so a real FileUtils.cp_r has real directory-tree content to walk.
+  # A stand-in for the gem's vendor/unity/src, with a nested file to show subdirectories copy
   def flattened_config(dir)
-    unity_src = File.join(dir, 'gem_vendor', 'unity', 'src')
-    FileUtils.mkdir_p(unity_src)
-    File.write(File.join(unity_src, 'unity.c'), "// stand-in for the real unity.c\n")
+    unity_src = File.join( dir, 'gem_vendor', 'unity', 'src' )
+    FileUtils.mkdir_p( File.join( unity_src, 'internal' ) )
+    File.write( File.join( unity_src, 'unity.c' ), "// stand-in for unity.c\n" )
+    File.write( File.join( unity_src, 'unity.h' ), "// stand-in for unity.h\n" )
+    File.write( File.join( unity_src, 'internal', 'unity_internals.h' ), "// stand-in\n" )
 
     {
-      # UNITY_LIB_PATH ('unity/src') is joined onto this root -- it must be the
-      # vendor root, not 'unity' itself, matching CEEDLING_VENDOR's real shape.
-      unity_vendor_path:                     File.join(dir, 'gem_vendor'),
-      project_build_vendor_unity_path:       File.join(dir, 'build', 'vendor', 'unity', 'src'),
-      project_use_mocks:                     false,
-      project_use_exceptions:                false,
-      project_use_backtrace:                 false,
-      project_use_partials:                  false,
+      # UNITY_LIB_PATH ('unity/src') joins this vendor root
+      unity_vendor_path:               File.join( dir, 'gem_vendor' ),
+      project_build_vendor_unity_path: File.join( dir, 'build', 'vendor', 'unity', 'src' ),
+      project_use_mocks:               false,
+      project_use_exceptions:          false,
+      project_use_backtrace:           :none,
+      project_use_partials:            false,
     }
   end
 
-  it "recovers from a transient copy failure on its own vendor destination instead of crashing the build" do
+  def vendor(file_wrapper, dir, config)
+    build_configurator_setup( file_wrapper ).vendor_frameworks_and_support_files( dir, config, test_build: true, release_build: false )
+  end
+
+  def snapshot(dest)
+    return Dir.glob( File.join( dest, '**', '*' ) ).select { |path| File.file?( path ) }.to_h do |path|
+      stat = File.stat( path )
+      [path, [stat.ino, stat.mtime]]
+    end
+  end
+
+  def leftovers(dest)
+    return Dir.glob( File.join( dest, '**', '*' ), File::FNM_DOTMATCH ).select { |path| File.basename( path ).include?( '.tmp' ) }
+  end
+
+  it "copies every file, including those in subdirectories, into a fresh destination" do
     with_source_tree({}) do |dir|
-      config = flattened_config(dir)
+      config = flattened_config( dir )
       dest = config[:project_build_vendor_unity_path]
-      # Real usage always runs build_directory_structure (which mkdir_p's every
-      # vendor destination) before this copy -- match that precondition here so the
-      # only fault in play is the one this spec injects, not a missing parent dir.
-      FileUtils.mkdir_p(dest)
-
-      # Exactly one raise, well within cp_r_with_retry's own retry budget -- the
-      # source is otherwise 100% fine, the real copy proceeds either way.
-      faulting_fw = CpRFaultingFileWrapper.new(
-        fault_dest: dest, raises_left: 1,
-        loginator: IntegrationSpecHelpers::NULL, verbosinator: IntegrationSpecHelpers::NULL
-      )
-      setup = build_configurator_setup(faulting_fw)
 
-      expect {
-        setup.vendor_frameworks_and_support_files(dir, config)
-      }.not_to raise_error
+      vendor( file_wrapper, dir, config )
 
-      expect(File.exist?(File.join(dest, 'unity.c'))).to be true
+      expect( File.read( File.join( dest, 'unity.h' ) ) ).to eq( "// stand-in for unity.h\n" )
+      expect( File.exist?( File.join( dest, 'internal', 'unity_internals.h' ) ) ).to be(true)
+      expect( leftovers( dest ) ).to be_empty
     end
   end
 
-  it "still raises a clear, path-naming CeedlingException when the fault never clears" do
+  it "rewrites nothing when the destination already matches" do
     with_source_tree({}) do |dir|
-      config = flattened_config(dir)
+      config = flattened_config( dir )
       dest = config[:project_build_vendor_unity_path]
-      FileUtils.mkdir_p(dest)
+      vendor( file_wrapper, dir, config )
+      before = snapshot( dest )
+      sleep( 1.1 ) # Past the coarsest file modification time resolution
 
-      # More raises than cp_r_with_retry's own retry budget (initial attempt + 4
-      # retries) -- every attempt fails, so the fault genuinely never clears.
-      permanently_faulting_fw = CpRFaultingFileWrapper.new(
-        fault_dest: dest, raises_left: 999,
-        loginator: IntegrationSpecHelpers::NULL, verbosinator: IntegrationSpecHelpers::NULL
-      )
-      setup = build_configurator_setup(permanently_faulting_fw)
+      vendor( file_wrapper, dir, config )
+
+      expect( snapshot( dest ) ).to eq( before )
+    end
+  end
+
+  it "restores an edited file by replacing it whole, and leaves matching files alone" do
+    with_source_tree({}) do |dir|
+      config = flattened_config( dir )
+      dest = config[:project_build_vendor_unity_path]
+      vendor( file_wrapper, dir, config )
+      edited = File.join( dest, 'unity.h' )
+      File.write( edited, "// an errant edit\n" )
+      before = snapshot( dest )
+
+      vendor( file_wrapper, dir, config )
+
+      expect( File.read( edited ) ).to eq( "// stand-in for unity.h\n" )
+      expect( File.stat( edited ).ino ).not_to eq( before[edited].first ) unless SystemWrapper.windows?
+      untouched = File.join( dest, 'unity.c' )
+      expect( snapshot( dest )[untouched] ).to eq( before[untouched] )
+      expect( leftovers( dest ) ).to be_empty
+    end
+  end
+
+  it "restores a missing file" do
+    with_source_tree({}) do |dir|
+      config = flattened_config( dir )
+      dest = config[:project_build_vendor_unity_path]
+      vendor( file_wrapper, dir, config )
+      FileUtils.rm( File.join( dest, 'internal', 'unity_internals.h' ) )
+
+      vendor( file_wrapper, dir, config )
+
+      expect( File.exist?( File.join( dest, 'internal', 'unity_internals.h' ) ) ).to be(true)
+    end
+  end
+
+  it "recovers from a transient copy failure instead of crashing the build" do
+    with_source_tree({}) do |dir|
+      config = flattened_config( dir )
+      dest = config[:project_build_vendor_unity_path]
+
+      expect { vendor( file_wrapper( fault_dir: dest, raises_left: 1 ), dir, config ) }.not_to raise_error
+
+      expect( File.exist?( File.join( dest, 'unity.c' ) ) ).to be(true)
+      expect( leftovers( dest ) ).to be_empty
+    end
+  end
+
+  it "raises a clear, path-naming CeedlingException when the fault never clears" do
+    with_source_tree({}) do |dir|
+      config = flattened_config( dir )
+      dest = config[:project_build_vendor_unity_path]
 
       expect {
-        setup.vendor_frameworks_and_support_files(dir, config)
-      }.to raise_error(CeedlingException, /#{Regexp.escape(dest)}/)
+        vendor( file_wrapper( fault_dir: dest, raises_left: 999 ), dir, config )
+      }.to raise_error( CeedlingException, /#{Regexp.escape( dest )}/ )
     end
   end
 end

data/spec/support/integration/configurator_integration_helper.rb

@@ -100,7 +100,8 @@ module ConfiguratorIntegrationHelpers
   end
 
   # Processes `yaml` as a build's setup would and returns the object graph
-  def configure(yaml, include_test_case: '', exclude_test_case: '', plugins_path: File.join( CEEDLING_ROOT_PATH, 'plugins' ))
+  # `test_build:` stands for the requested tasks building tests, which populates build/vendor
+  def configure(yaml, include_test_case: '', exclude_test_case: '', test_build: true, plugins_path: File.join( CEEDLING_ROOT_PATH, 'plugins' ))
     objects = configurator_objects( quiet_loginator )
     objects[:configurator_builder].constants_namespace = constants
 
@@ -121,6 +122,8 @@ module ConfiguratorIntegrationHelpers
       include_test_case:     include_test_case,
       exclude_test_case:     exclude_test_case,
       force_test_rerun:      false,
+      test_build_tasks?:     test_build,
+      release_build_tasks?:  false,
       log_filepath:          nil,
       ceedling_plugins_path: plugins_path,
       ceedling_lib_path:     File.join( CEEDLING_ROOT_PATH, 'lib', 'ceedling' ),

data/spec/units/bin/app_cfg_spec.rb

@@ -81,6 +81,16 @@ describe CeedlingAppConfig do
       expect(@app_cfg.build_tasks?).to eq( true )
     end
 
+    it '#set_test_build_tasks and #set_release_build_tasks update their flags, which default to false' do
+      expect(@app_cfg.test_build_tasks?).to eq( false )
+      expect(@app_cfg.release_build_tasks?).to eq( false )
+
+      @app_cfg.set_test_build_tasks( true )
+      @app_cfg.set_release_build_tasks( true )
+      expect(@app_cfg.test_build_tasks?).to eq( true )
+      expect(@app_cfg.release_build_tasks?).to eq( true )
+    end
+
     it '#set_tests_graceful_fail updates :tests_graceful_fail? and #tests_graceful_fail?' do
       @app_cfg.set_tests_graceful_fail( true )
       expect(@app_cfg[:tests_graceful_fail?]).to eq( true )

data/spec/units/bin/cli_handler_spec.rb

@@ -109,7 +109,8 @@ describe CliHandler do
       )
 
       expect(@loginator).to receive(:console) do |message, _label|
-        expect(message).to include( 'Ceedling Launcher => 1.2.0' )
+        # 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
 

data/spec/units/bin/cli_helper_spec.rb

@@ -111,6 +111,16 @@ describe CliHelper do
     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

data/spec/units/config/configurator_setup_spec.rb

@@ -225,74 +225,93 @@ describe ConfiguratorSetup do
     end
   end
 
+  # Only a build populates build/vendor, so a command that only reads the project, such as
+  # files:test or dumpconfig, leaves a concurrent build's files alone (GH #1361)
   context "#vendor_frameworks_and_support_files" do
     def flattened_config
       {
-        unity_vendor_path:                  '/gem/vendor/unity',
+        unity_vendor_path:                  '/gem/vendor',
         project_build_vendor_unity_path:    '/build/vendor/unity/src',
-        cmock_vendor_path:                  '/gem/vendor/cmock',
+        cmock_vendor_path:                  '/gem/vendor',
         project_build_vendor_cmock_path:    '/build/vendor/cmock/src',
-        cexception_vendor_path:             '/gem/vendor/c_exception',
+        cexception_vendor_path:             '/gem/vendor',
         project_build_vendor_cexception_path: '/build/vendor/c_exception/lib',
+        project_build_vendor_ceedling_path: '/build/vendor/ceedling',
+        project_build_tests_root:           '/build/test',
         project_use_mocks:                  true,
         project_use_exceptions:             true,
-        project_use_backtrace:              false,
-        project_use_partials:               false,
+        project_use_backtrace:              :gdb,
+        project_use_partials:               true,
       }
     end
 
     before(:each) do
       allow(@file_wrapper).to receive(:exist?).and_return(false)
       allow(@file_wrapper).to receive(:rm_rf)
-      allow(@file_wrapper).to receive(:cp_r_with_retry)
+      allow(@file_wrapper).to receive(:mkdir)
+      allow(@file_wrapper).to receive(:sync_tree)
+      allow(@file_wrapper).to receive(:sync_file)
     end
 
-    it "copies the gdb backtrace script and the Partials header when those features are in use" do
-      allow(@file_wrapper).to receive(:mkdir)
-      allow(@file_wrapper).to receive(:cp_r)
-      config = flattened_config.merge(
-        project_use_backtrace: :gdb, project_build_tests_root: '/build/test',
-        project_use_partials: true, project_build_vendor_ceedling_path: '/build/vendor/ceedling'
-      )
+    def vendor(config = flattened_config, test_build: false, release_build: false)
+      @setup.vendor_frameworks_and_support_files( '/gem/lib', config, test_build: test_build, release_build: release_build )
+    end
 
-      @setup.vendor_frameworks_and_support_files('/gem/lib', config)
+    def synced_trees
+      synced = []
+      allow(@file_wrapper).to receive(:sync_tree) { |source, destination| synced << [source, destination] }
+      yield
+      return synced
+    end
+
+    it "brings Unity, CMock, CException, the gdb backtrace script and the Partials header up to date for a test build" do
+      synced = synced_trees { vendor( test_build: true ) }
 
+      expect(synced).to eq( [
+        ['/gem/vendor/unity/src', '/build/vendor/unity/src'],
+        ['/gem/vendor/cmock/src', '/build/vendor/cmock/src'],
+        ['/gem/vendor/c_exception/lib', '/build/vendor/c_exception/lib']
+      ] )
       expect(@file_wrapper).to have_received(:mkdir).with('/build/test')
-      expect(@file_wrapper).to have_received(:cp_r).with(File.join('/gem/lib', BACKTRACE_GDB_SCRIPT_FILE), '/build/test')
-      expect(@file_wrapper).to have_received(:cp_r).with('/gem/lib/ceedling.h', '/build/vendor/ceedling')
+      expect(@file_wrapper).to have_received(:sync_file).with(File.join('/gem/lib', BACKTRACE_GDB_SCRIPT_FILE), '/build/test')
+      expect(@file_wrapper).to have_received(:sync_file).with('/gem/lib/ceedling.h', '/build/vendor/ceedling')
     end
 
-    it "always copies Unity, CMock, and CException, regardless of whether the destination looks already populated" do
-      # A prior run's destination "looking populated and uncorrupted" is exactly the
-      # state a skip-check would trust -- simulate it directly (dest is a real
-      # directory, its marker file is a real file, nothing corrupted) to prove there
-      # is no such skip.
-      allow(@file_wrapper).to receive(:exist?).and_return(true)
-      allow(@file_wrapper).to receive(:directory?) do |path|
-        !path.end_with?('.c') # marker files (unity.c, cmock.c, CException.c) are plain files; their parent dirs are directories
-      end
+    it "leaves out CMock, CException, the backtrace script and the Partials header when a test build doesn't use them" do
+      config = flattened_config.merge( project_use_mocks: false, project_use_exceptions: false, project_use_backtrace: :simple, project_use_partials: false )
 
-      @setup.vendor_frameworks_and_support_files('/gem/lib', flattened_config)
+      synced = synced_trees { vendor( config, test_build: true ) }
 
-      expect(@file_wrapper).to have_received(:cp_r_with_retry)
-        .with(a_string_including('/gem/vendor/unity'), '/build/vendor/unity/src')
-      expect(@file_wrapper).to have_received(:cp_r_with_retry)
-        .with(a_string_including('/gem/vendor/cmock'), '/build/vendor/cmock/src')
-      expect(@file_wrapper).to have_received(:cp_r_with_retry)
-        .with(a_string_including('/gem/vendor/c_exception'), '/build/vendor/c_exception/lib')
+      expect(synced).to eq( [['/gem/vendor/unity/src', '/build/vendor/unity/src']] )
+      expect(@file_wrapper).to_not have_received(:sync_file)
     end
 
-    it "skips CMock and CException copying when the project doesn't use them" do
-      config = flattened_config.merge(project_use_mocks: false, project_use_exceptions: false)
+    it "brings only CException up to date for a release build" do
+      synced = synced_trees { vendor( release_build: true ) }
+
+      expect(synced).to eq( [['/gem/vendor/c_exception/lib', '/build/vendor/c_exception/lib']] )
+      expect(@file_wrapper).to_not have_received(:sync_file)
+    end
+
+    it "copies nothing for a release build without exceptions" do
+      vendor( flattened_config.merge( project_use_exceptions: false ), release_build: true )
+
+      expect(@file_wrapper).to_not have_received(:sync_tree)
+      expect(@file_wrapper).to_not have_received(:sync_file)
+    end
+
+    it "copies each framework once when a command builds both tests and a release" do
+      synced = synced_trees { vendor( test_build: true, release_build: true ) }
+
+      expect(synced.map( &:last )).to eq( ['/build/vendor/unity/src', '/build/vendor/cmock/src', '/build/vendor/c_exception/lib'] )
+    end
 
-      @setup.vendor_frameworks_and_support_files('/gem/lib', config)
+    it "touches nothing beneath build/vendor for a command that builds nothing" do
+      vendor
 
-      expect(@file_wrapper).to have_received(:cp_r_with_retry)
-        .with(a_string_including('/gem/vendor/unity'), '/build/vendor/unity/src')
-      expect(@file_wrapper).to_not have_received(:cp_r_with_retry)
-        .with(a_string_including('/gem/vendor/cmock'), anything)
-      expect(@file_wrapper).to_not have_received(:cp_r_with_retry)
-        .with(a_string_including('/gem/vendor/c_exception'), anything)
+      expect(@file_wrapper).to_not have_received(:sync_tree)
+      expect(@file_wrapper).to_not have_received(:sync_file)
+      expect(@file_wrapper).to_not have_received(:rm_rf)
     end
 
     it "heals a corrupted (wrong-typed) vendor destination before copying" do
@@ -300,13 +319,12 @@ describe ConfiguratorSetup do
       allow(@file_wrapper).to receive(:directory?).with('/build/vendor/unity/src').and_return(false)
       allow(@loginator).to receive(:log)
 
-      @setup.vendor_frameworks_and_support_files('/gem/lib', flattened_config)
+      vendor( test_build: true )
 
       expect(@file_wrapper).to have_received(:rm_rf).with('/build/vendor/unity/src')
     end
   end
 
-  # The validations below log each problem they find and report overall validity
   context "configuration validation" do
     before(:each) do
       allow(@loginator).to receive(:log)

data/spec/units/config/configurator_spec.rb

@@ -902,13 +902,22 @@ describe Configurator do
       flattened = { flat_a: 1, flat_environment: [ { cc: 'gcc' } ] }
       expect( @configurator_setup ).to have_received(:build_project_config).with( 'lib', 'logs', flattened ).ordered
       expect( @configurator_setup ).to have_received(:build_directory_structure).with( flattened ).ordered
-      expect( @configurator_setup ).to have_received(:vendor_frameworks_and_support_files).with( 'lib', flattened ).ordered
+      expect( @configurator_setup ).to have_received(:vendor_frameworks_and_support_files).with( 'lib', flattened, test_build: false, release_build: false ).ordered
       expect( @configurator_setup ).to have_received(:build_project_collections).with( flattened ).ordered
       expect( @configurator_setup ).to have_received(:build_constants_and_accessors).with( flattened, anything ).ordered
       expect( @configurator_setup ).to have_received(:build_constants_and_accessors).with( { environment: [ { cc: 'gcc' } ] }, anything ).ordered
       expect( @configurator.project_config_hash ).to eq( flattened )
     end
 
+    it "copies the vendor files the requested build tasks need" do
+      @configurator.test_build_tasks = true
+      @configurator.release_build_tasks = true
+
+      @configurator.build( 'lib', 'logs', { a: 1 } )
+
+      expect( @configurator_setup ).to have_received(:vendor_frameworks_and_support_files).with( 'lib', { flat_a: 1 }, test_build: true, release_build: true )
+    end
+
     it "redefines an existing element and its constant" do
       @configurator.build( 'lib', 'logs', { a: 1 } )
 

data/spec/units/file_wrapper_spec.rb

@@ -6,6 +6,7 @@
 # =========================================================================
 
 require 'spec_helper'
+require 'tmpdir'
 require 'ceedling/file_wrapper'
 require 'ceedling/system_wrapper'
 require 'ceedling/exceptions'
@@ -215,49 +216,87 @@ describe FileWrapper do
   # a vendor destination briefly reporting the wrong file/directory type mid-copy).
   # Stub-based, matching #open_with_retry's own spec above -- no real filesystem or
   # timing involved.
-  describe '#cp_r_with_retry' do
+  # A transient error mid-copy (a path briefly the wrong type, a file another process holds
+  # open on Windows) is retried; one that never clears names the destination.
+  describe '#sync_tree retries' do
     before(:each) do
       allow(@file_wrapper).to receive(:sleep)
     end
 
-    it 'behaves identically to #cp_r when nothing fails' do
-      allow(FileUtils).to receive(:cp_r)
+    def with_tree
+      Dir.mktmpdir do |dir|
+        source = File.join( dir, 'src' )
+        FileUtils.mkdir_p( source )
+        File.write( File.join( source, 'unity.c' ), "int x;\n" )
+        yield source, File.join( dir, 'dest' )
+      end
+    end
 
-      @file_wrapper.cp_r_with_retry('/src/.', '/dest')
+    it 'copies without retrying when nothing fails' do
+      with_tree do |source, dest|
+        @file_wrapper.sync_tree( source, dest )
 
-      expect(FileUtils).to have_received(:cp_r).with('/src/.', '/dest')
-      expect(@file_wrapper).not_to have_received(:sleep)
+        expect( File.read( File.join( dest, 'unity.c' ) ) ).to eq( "int x;\n" )
+        expect(@file_wrapper).not_to have_received(:sleep)
+      end
     end
 
-    it 'retries past a SystemCallError and succeeds once the underlying copy stops raising' do
-      call_count = 0
-      allow(FileUtils).to receive(:cp_r) do
-        call_count += 1
-        raise Errno::EISDIR, 'transient' if call_count < 3
-      end
+    it 'retries past a SystemCallError and succeeds once the copy stops raising' do
+      with_tree do |source, dest|
+        calls = 0
+        allow(@file_wrapper).to receive(:replace_file).and_wrap_original do |original, *args|
+          calls += 1
+          raise Errno::EISDIR, 'transient' if calls < 3
+          original.call( *args )
+        end
 
-      @file_wrapper.cp_r_with_retry('/src/.', '/dest')
+        @file_wrapper.sync_tree( source, dest )
 
-      expect(call_count).to eq(3)
-      expect(@file_wrapper).to have_received(:sleep).twice
+        expect( calls ).to eq( 3 )
+        expect(@file_wrapper).to have_received(:sleep).twice
+        expect( File.exist?( File.join( dest, 'unity.c' ) ) ).to be(true)
+      end
     end
 
-    it 'raises a CeedlingException naming the destination and retry count once every retry is exhausted, and logs it' do
-      allow(FileUtils).to receive(:cp_r).and_raise(Errno::ENOTDIR, 'still wrong type')
+    it 'raises a CeedlingException naming the destination once every retry is exhausted, and logs it' do
+      with_tree do |source, dest|
+        allow(@file_wrapper).to receive(:replace_file).and_raise( Errno::ENOTDIR, 'still wrong type' )
 
-      expect { @file_wrapper.cp_r_with_retry('/src/.', '/dest') }.to raise_error(CeedlingException, /\/dest/)
-      expect(@loginator).to have_received(:log).with(a_string_including('/dest'), Verbosity::ERRORS)
-      # Initial attempt + one retry per configured delay.
-      expect(FileUtils).to have_received(:cp_r).exactly(FileWrapper::TRANSIENT_IO_RETRY_DELAYS.size + 1).times
+        expect { @file_wrapper.sync_tree( source, dest ) }.to raise_error( CeedlingException, /#{Regexp.escape( dest )}/ )
+        expect(@loginator).to have_received(:log).with( a_string_including( dest ), Verbosity::ERRORS )
+        # Initial attempt plus one retry for each configured delay
+        expect(@file_wrapper).to have_received(:replace_file).exactly( FileWrapper::TRANSIENT_IO_RETRY_DELAYS.size + 1 ).times
+      end
     end
 
-    it 'does not retry a non-SystemCallError -- propagates immediately' do
-      allow(FileUtils).to receive(:cp_r).and_raise(ArgumentError, 'not transient')
+    it 'propagates an error that is not a SystemCallError without retrying' do
+      with_tree do |source, dest|
+        allow(@file_wrapper).to receive(:replace_file).and_raise( ArgumentError, 'not transient' )
 
-      expect {
-        @file_wrapper.cp_r_with_retry('/src/.', '/dest')
-      }.to raise_error(ArgumentError, 'not transient')
-      expect(@file_wrapper).not_to have_received(:sleep)
+        expect { @file_wrapper.sync_tree( source, dest ) }.to raise_error( ArgumentError, 'not transient' )
+        expect(@file_wrapper).not_to have_received(:sleep)
+      end
+    end
+  end
+
+  # The temporary copy beside the destination is the longest path replace_file writes
+  describe '#replace_file' do
+    it 'checks the length of its temporary path, then leaves only the destination' do
+      Dir.mktmpdir do |dir|
+        source = File.join( dir, 'unity.h' )
+        destination = File.join( dir, 'out', 'unity.h' )
+        File.write( source, "int x;\n" )
+        FileUtils.mkdir_p( File.dirname( destination ) )
+        checked = []
+        allow(@file_wrapper).to receive(:check_path_length) { |path, **| checked << path }
+
+        @file_wrapper.replace_file( source, destination )
+
+        expect( checked.size ).to eq( 1 )
+        expect( File.dirname( checked.first ) ).to eq( File.dirname( destination ) )
+        expect( checked.first.length ).to be > destination.length
+        expect( Dir.children( File.dirname( destination ) ) ).to eq( ['unity.h'] )
+      end
     end
   end