miga-base 1.4.3.1 → 1.4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a71abecf373fd0b61a6148010a4c4f2ae08bb1088fbc5c185c95a2e35e761d74
-  data.tar.gz: 021b16610dbf57f81e31e04745bbf04189fe82a836245883c4f68fe80ef99cf6
+  metadata.gz: b3befac28b6f332444a88067d1e04a8fe9f3d77e3800b6363be17fec49cee367
+  data.tar.gz: a68987776138c7752183a4eadc14fe42ca95eb971b721bf41830f16548bf859e
 SHA512:
-  metadata.gz: ebdc34e46e478e58d83842ac93c913e413cfc9ee526429a6b4be026fa73217d5fc44863c896b67d6eb11c70cf527273a659f2d429caf9b873146d40f6a31dce7
-  data.tar.gz: 17d801e447570c9390295828f3317649080c4d9d2d1c6f9e1a39f8c3903b5bd8aa2a6f2dbc9e702210d75dc4e72a99b14bce6bd1b56c856bf1b46d0ebe53e220
+  metadata.gz: 44ed6636bbbd92e7d383e6b462e17c3dfc7da82535224b380fe8c05afd243ed9b3d86c81fc55c784973f1578377030f39288ab939cec5059100da19cdd314c8a
+  data.tar.gz: b5acca6e95002b45bdf18a8dab953ead9cb9d62c048602e26ef2c82981880d9794c96ba85b801440a0f9581e7ef3e2d43598456897bb3752f5cf024db4b08bf9

data/lib/miga/remote_dataset/base.rb

@@ -18,7 +18,7 @@ def uri_safe_join(*parts)
 end
 
 module MiGA::RemoteDataset::Base
-  @@_NCBI_DATASETS = 'https://api.ncbi.nlm.nih.gov/datasets/v2alpha/'
+  @@_NCBI_DATASETS = 'https://api.ncbi.nlm.nih.gov/datasets/v2/'
   @@_EUTILS        = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/'
   @@_EBI_API       = 'https://www.ebi.ac.uk/Tools/'
   @@_GTDB_API      = 'https://gtdb-api.ecogenomic.org/'
@@ -173,6 +173,21 @@ module MiGA::RemoteDataset::Base
         end
       end
     },
+    ncbi_datasets_report: {
+      dbs: { genome: { stage: :metadata, format: :json } },
+      uri: lambda do |opts|
+        uri_safe_join(
+          @@_NCBI_DATASETS, opts[:db], :accession, opts[:ids], :dataset_report
+        )
+      end,
+      method: :get,
+      headers: lambda do |opts|
+        {}.tap do |h|
+          h['Accept'] = 'application/json' if opts[:format] == :json
+          h['api-key'] = ENV['NCBI_API_KEY'] if ENV['NCBI_API_KEY']
+        end
+      end
+    },
     ncbi_datasets: {
       dbs: {
         genome: {

data/lib/miga/remote_dataset/download.rb

@@ -19,9 +19,6 @@ class MiGA::RemoteDataset
       getter = database_hash[:getter] || :download
       action = database_hash[:method] || universe_hash[:method]
 
-      # Clean IDs
-      ids = 
-
       # Return options
       {
         universe: universe,  db:   db,    ids: ids.is_a?(Array) ? ids : [ids],
@@ -60,11 +57,10 @@ class MiGA::RemoteDataset
       begin
         ncbi_asm_get(opts)
       rescue
-        # The actual error thrown by `ncbi_asm_get` is rather uniformative and
-        # could change in the future. Right now, the URL resolves correctly, but
-        # the file is corrupted, so the actual error is `Zip::Error`. Hopefully
-        # NCBI will implement an actual 404 Error that can be caught here more
-        # narrowly, but for now it's safer to catch broadly here.
+        # Missing or unavailable assemblies are reported by `ncbi_asm_get` as
+        # MiGA::RemoteDataError (or its subclass MiGA::RemoteDataMissingError),
+        # but network errors and other transient failures can surface with
+        # different classes, so it's safer to catch broadly here.
 
         opts_embl = opts.dup.merge(universe: :ebi, db: :embl)
         download_get(opts_embl)
@@ -79,12 +75,25 @@ class MiGA::RemoteDataset
     # +file+ (mandatory): String, assembly saved here
     # +extra+: Hash, passed to download
     # +format+: String, ignored
+    #
+    # Unversioned accessions (e.g., GCA_000175575) are first resolved to their
+    # current version (see +ncbi_asm_resolve_acc+), and the resolved accessions
+    # are registered in the +:ncbi_asm+ metadata entry of +obj+, if any.
+    #
+    # Raises MiGA::RemoteDataMissingError if the downloaded archive is invalid
+    # or doesn't contain any genomic FastA file
     def ncbi_asm_get(opts)
       require 'tempfile'
       require 'zip'
 
+      ids = (opts[:ids].is_a?(Array) ? opts[:ids] : [opts[:ids]])
+      acc = ids.map { |id| ncbi_asm_resolve_acc(id) }
+      if acc != ids && opts[:obj].respond_to?(:metadata)
+        opts[:obj].metadata[:ncbi_asm] = acc.join(',')
+      end
+
       zipped = download(
-        :ncbi_datasets_download, :genome, opts[:ids],
+        :ncbi_datasets_download, :genome, acc,
         :zip, nil, opts[:extra], opts[:obj]
       )
       zip_tmp = Tempfile.new(['asm', '.zip'], encoding: zipped.encoding.to_s)
@@ -92,22 +101,74 @@ class MiGA::RemoteDataset
       zip_tmp.close
 
       o = ''
+      found = false
       ofh = opts[:file] ? File.open(opts[:file], 'w') : nil
-      Zip::File.open(zip_tmp.path) do |zfh|
-        zfh.each do |entry|
-          if entry.file? && entry.name =~ /_genomic\.fna$/
-            DEBUG "Extracting: #{entry.name}"
-            entry.get_input_stream do |ifh|
-              cont = MiGA::MiGA.normalize_encoding(ifh.read).chomp + "\n"
-              ofh&.print(cont)
-              o += cont
+      begin
+        Zip::File.open(zip_tmp.path) do |zfh|
+          zfh.each do |entry|
+            if entry.file? && entry.name =~ /_genomic\.fna$/
+              DEBUG "Extracting: #{entry.name}"
+              found = true
+              entry.get_input_stream do |ifh|
+                cont = MiGA::MiGA.normalize_encoding(ifh.read).chomp + "\n"
+                ofh&.print(cont)
+                o += cont
+              end
             end
           end
         end
+      rescue Zip::Error => e
+        raise MiGA::RemoteDataMissingError.new(
+          "NCBI Datasets returned an invalid archive for #{acc.join(',')} " \
+          "(#{zipped.bytesize} bytes): #{e.message}"
+        )
+      end
+      unless found
+        raise MiGA::RemoteDataMissingError.new(
+          "NCBI Datasets returned no genomic sequences for #{acc.join(',')}"
+        )
       end
-      ofh&.close
-      File.unlink(zip_tmp.path)
       o
+    ensure
+      ofh&.close
+      zip_tmp&.close!
+    end
+
+    ##
+    # Resolve the NCBI Assembly Accession +acc+ to its current versioned
+    # accession using NCBI Datasets if it lacks a version (e.g., GCA_000175575
+    # is resolved to GCA_000175575.2). Any other accession is returned as is.
+    #
+    # Raises MiGA::RemoteDataMissingError if the accession is not found, or
+    # MiGA::RemoteDataError if the response from NCBI cannot be interpreted
+    def ncbi_asm_resolve_acc(acc)
+      return acc unless acc.to_s =~ /\AGC[AF]_\d{9}\z/
+
+      doc = download(:ncbi_datasets_report, :genome, acc, :json)
+      begin
+        report = MiGA::Json.parse(doc, contents: true)
+      rescue => e
+        raise MiGA::RemoteDataError.new(
+          "Cannot resolve NCBI Assembly Accession #{acc}, " \
+          "unexpected response from NCBI Datasets: #{e.message}"
+        )
+      end
+      unless report.is_a?(Hash) && (report.empty? || report.key?(:reports))
+        raise MiGA::RemoteDataError.new(
+          "Cannot resolve NCBI Assembly Accession #{acc}, " \
+          "unexpected response from NCBI Datasets: #{doc[0, 200]}"
+        )
+      end
+
+      entry = (report[:reports] || []).first || {}
+      out = entry[:current_accession] || entry[:accession]
+      if out.nil? || out.empty?
+        raise MiGA::RemoteDataMissingError.new(
+          "NCBI Assembly Accession not found: #{acc}"
+        )
+      end
+      DEBUG "Resolved NCBI Assembly Accession: #{acc} -> #{out}"
+      out
     end
 
     ##
@@ -116,6 +177,7 @@ class MiGA::RemoteDataset
     def ncbi_gb_get(opts)
       # Simply use defaults, but ensure that the URL can be properly formed
       o = download_rest(opts.merge(universe: :ncbi, db: :nuccore))
+      ncbi_efetch_check(o, opts[:ids])
       return o unless o.strip.empty?
 
       begin
@@ -137,9 +199,35 @@ class MiGA::RemoteDataset
       end
       ids.each_slice(20).map do |bunch|
         download_rest(opts.merge(universe: :ncbi, db: :nuccore, ids: bunch))
+          .tap { |doc| ncbi_efetch_check(doc, bunch) }
       end.join("\n")
     end
 
+    ##
+    # Check if +doc+ is an error message returned by NCBI efetch for +ids+
+    # (with HTTP status 200), and raise an exception if so. Unrecognized
+    # IDs raise MiGA::RemoteDataMissingError, and any other error raises
+    # MiGA::RemoteDataError
+    def ncbi_efetch_check(doc, ids)
+      return unless doc =~ /\A\s*Error:/
+
+      # NCBI sometimes spaces out the characters in the message, as in
+      # "F a i l e d  t o  u n d e r s t a n d  i d"
+      msg = doc.strip.sub(/\AError:\s*/, '')
+      msg = msg.gsub(/(?<! ) (?! )/, '') if msg =~ /\A(\S ){3}/
+      msg = msg.gsub(/\s+/, ' ').strip
+      ids = ids.is_a?(Array) ? ids.join(',') : ids.to_s
+
+      if msg =~ /Failed to understand id|not found/i
+        raise MiGA::RemoteDataMissingError.new(
+          "NCBI nuccore entry not found: #{ids} (efetch: #{msg})"
+        )
+      end
+      raise MiGA::RemoteDataError.new(
+        "NCBI efetch failed for nuccore entry #{ids}: #{msg}"
+      )
+    end
+
     ##
     # Download data using the GET method. Supported +opts+ (Hash) include:
     # +universe+ (mandatory): Symbol
@@ -212,21 +300,52 @@ class MiGA::RemoteDataset
     ##
     # Looks for the entry +id+ in +dbfrom+, and returns the linked
     # identifier in +db+ (or nil).
+    #
+    # Raises MiGA::RemoteDataMissingError if NCBI doesn't recognize +id+ in
+    # +dbfrom+, or MiGA::RemoteDataError if the response cannot be interpreted
+    # even after one retry
     def ncbi_map(id, dbfrom, db)
+      attempts ||= 0
       doc = download(:ncbi_map, dbfrom, id, :json, nil, db: db)
       return if doc.empty?
 
-      begin
-        tree = MiGA::Json.parse(doc, contents: true)
-      rescue => e
-        sleep 5 # <- Usually caused by busy servers: BLOB ID IS NOT IMPLEMENTED
-        DEBUG "RETRYING after: #{e}"
-        doc = download(:ncbi_map, dbfrom, id, :json, nil, db: db)
-        return if doc.empty?
-        tree = MiGA::Json.parse(doc, contents: true)
+      # NCBI may include raw control characters within strings (e.g., in ERROR
+      # messages), which is invalid JSON, but harmless to replace with spaces
+      tree = MiGA::Json.parse(doc.gsub(/[[:cntrl:]]/, ' '), contents: true)
+      linkset = tree.is_a?(Hash) ? (tree.dig(:linksets, 0) || {}) : {}
+      error = linkset[:ERROR] ||
+        (linkset[:linksetdbs] || []).map { |i| i[:ERROR] }.compact.first
+      if error
+        # Errors with an empty list of IDs indicate that +id+ is not recognized
+        # in +dbfrom+ (e.g., BLOB ID IS NOT IMPLEMENTED), so there's no point
+        # in retrying
+        if (linkset[:ids] || []).empty?
+          raise MiGA::RemoteDataMissingError.new(
+            "NCBI #{dbfrom} entry not found: #{id} " \
+            "(elink: #{error.to_s.squeeze(' ').strip})"
+          )
+        end
+        raise MiGA::RemoteDataError.new(
+          "NCBI elink failed for #{dbfrom} entry #{id}: " \
+          "#{error.to_s.squeeze(' ').strip}"
+        )
       end
 
-      tree&.dig(:linksets, 0, :linksetdbs, 0, :links, 0)
+      linkset.dig(:linksetdbs, 0, :links, 0)
+    rescue MiGA::RemoteDataMissingError
+      raise
+    rescue JSON::ParserError, MiGA::RemoteDataError => e
+      # Any other error in the response is possibly transient (e.g., busy
+      # servers), so retry once before giving up
+      if (attempts += 1) > 1
+        raise e if e.is_a?(MiGA::RemoteDataError)
+        raise MiGA::RemoteDataError.new(
+          "Unexpected response from NCBI elink for #{dbfrom} entry #{id}: #{e}"
+        )
+      end
+      sleep 5
+      DEBUG "RETRYING after: #{e}"
+      retry
     end
 
     ##

data/lib/miga/remote_dataset.rb

@@ -368,11 +368,17 @@ class MiGA::RemoteDataset < MiGA::MiGA
   def get_type_status_ncbi_nuccore(metadata)
     return metadata if metadata[:ncbi_nuccore].nil?
 
-    biosample =
-      self.class.ncbi_map(metadata[:ncbi_nuccore], :nuccore, :biosample)
-    return metadata if biosample.nil?
-
-    asm = self.class.ncbi_map(biosample, :biosample, :assembly)
+    begin
+      biosample =
+        self.class.ncbi_map(metadata[:ncbi_nuccore], :nuccore, :biosample)
+      return metadata if biosample.nil?
+
+      asm = self.class.ncbi_map(biosample, :biosample, :assembly)
+    rescue MiGA::RemoteDataMissingError => e
+      # Type status is best-effort, missing entries are reported on download
+      MiGA::MiGA.DEBUG "Cannot determine type status: #{e}"
+      return metadata
+    end
     metadata[:ncbi_asm] = asm.to_s unless asm.nil?
     get_type_status_ncbi_asm metadata
   end

data/lib/miga/version.rb

@@ -12,7 +12,7 @@ module MiGA
   # - String indicating release status:
   #   - rc* release candidate, not released as gem
   #   - [0-9]+ stable release, released as gem
-  VERSION = [1.4, 3, 1].freeze
+  VERSION = [1.4, 4, 0].freeze
 
   ##
   # Nickname for the current major.minor version.
@@ -20,7 +20,7 @@ module MiGA
 
   ##
   # Date of the current gem relese.
-  VERSION_DATE = Date.new(2026, 8, 7)
+  VERSION_DATE = Date.new(2026, 11, 9)
 
   ##
   # References of MiGA

data/test/remote_dataset_test.rb

@@ -215,6 +215,271 @@ class RemoteDatasetTest < Test::Unit::TestCase
     assert_equal('}', p[-1])
   end
 
+  def test_ncbi_datasets_report_request
+    # No remote access needed
+    rd = MiGA::RemoteDataset.new(
+      'GCA_000175575', :genome, :ncbi_datasets_report
+    )
+    u = rd.download_uri
+    h = rd.download_headers
+
+    assert(u.is_a? URI)
+    assert_equal('https', u.scheme)
+    assert_equal('dataset_report', File.basename(u.path))
+    assert_include(u.path, '/accession/GCA_000175575/')
+
+    assert(h.is_a? Hash)
+    assert_equal(1, h.size)
+    assert_equal('application/json', h['Accept'])
+
+    ENV['NCBI_API_KEY'] = 'Not-a-real-key'
+    h = rd.download_headers
+    ENV.delete('NCBI_API_KEY')
+    assert_equal(2, h.size)
+    assert_equal('Not-a-real-key', h['api-key'])
+  end
+
+  def test_ncbi_asm_resolve_acc_offline
+    report = {
+      'GCA_000175575' =>
+        '{"reports":[{"accession":"GCA_000175575.2",' \
+        '"current_accession":"GCA_000175575.2"}]}',
+      'GCA_999999999' => '{}',
+      'GCA_888888888' => '{"error":"Too Many Requests","code":429}',
+      'GCA_777777777' => '<html>Service unavailable</html>'
+    }
+    calls = []
+    with_stubbed_download(lambda do |universe, _db, ids, *_rest|
+      assert_equal(:ncbi_datasets_report, universe)
+      calls << ids
+      report[ids]
+    end) do
+      rd = MiGA::RemoteDataset
+      assert_equal('GCA_000175575.2', rd.ncbi_asm_resolve_acc('GCA_000175575'))
+      assert_equal(['GCA_000175575'], calls)
+
+      # Versioned (or non-assembly) accessions are not resolved
+      assert_equal('GCF_000175575.2', rd.ncbi_asm_resolve_acc('GCF_000175575.2'))
+      assert_equal('M30502.1', rd.ncbi_asm_resolve_acc('M30502.1'))
+      assert_equal(1, calls.size)
+
+      # Missing accessions
+      assert_raise(MiGA::RemoteDataMissingError) do
+        rd.ncbi_asm_resolve_acc('GCA_999999999')
+      end
+
+      # Unexpected responses are not reported as missing data
+      %w[GCA_888888888 GCA_777777777].each do |acc|
+        err = assert_raise(MiGA::RemoteDataError) do
+          rd.ncbi_asm_resolve_acc(acc)
+        end
+        assert_not_instance_of(MiGA::RemoteDataMissingError, err)
+      end
+    end
+  end
+
+  def test_ncbi_asm_get_bad_zip_offline
+    require 'zip'
+    # A truncated archive like the one NCBI returns for unversioned accessions
+    truncated = "PK\x03\x04\x14\x00\x00\x00\x08\x00README.md".b
+    # A valid archive without any genomic FastA file
+    no_fna = Zip::OutputStream.write_buffer do |zos|
+      zos.put_next_entry('README.md')
+      zos.write('Nothing to see here')
+    end.string
+
+    [truncated, no_fna].each do |zipped|
+      with_stubbed_download(lambda do |universe, *_rest|
+        assert_equal(:ncbi_datasets_download, universe)
+        zipped
+      end) do
+        file = tmpfile('asm.fna')
+        err = assert_raise(MiGA::RemoteDataMissingError) do
+          MiGA::RemoteDataset.ncbi_asm_get(
+            ids: ['GCA_000175575.2'], file: file, extra: {}
+          )
+        end
+        assert_include(err.message, 'GCA_000175575.2')
+      end
+    end
+  end
+
+  def test_ncbi_asm_get_offline
+    require 'zip'
+    zipped = Zip::OutputStream.write_buffer do |zos|
+      zos.put_next_entry(
+        'ncbi_dataset/data/GCA_000175575.2/GCA_000175575.2_ASM_genomic.fna'
+      )
+      zos.write(">ctg1\nACGT\n")
+    end.string
+    report =
+      '{"reports":[{"accession":"GCA_000175575.2",' \
+      '"current_accession":"GCA_000175575.2"}]}'
+
+    rd = MiGA::RemoteDataset.new('GCA_000175575', :assembly, :ncbi)
+    with_stubbed_download(lambda do |universe, _db, ids, *_rest|
+      case universe
+      when :ncbi_datasets_report
+        report
+      when :ncbi_datasets_download
+        assert_equal(['GCA_000175575.2'], ids)
+        zipped
+      end
+    end) do
+      file = tmpfile('asm.fna')
+      o = MiGA::RemoteDataset.ncbi_asm_get(
+        ids: rd.ids, file: file, extra: {}, obj: rd
+      )
+      assert_equal(">ctg1\nACGT\n", o)
+      assert_equal(">ctg1\nACGT\n", File.read(file))
+      assert_equal('GCA_000175575.2', rd.metadata[:ncbi_asm])
+      assert_equal('GCA_000175575', rd.metadata[:ncbi_assembly])
+    end
+  end
+
+  def test_ncbi_asm_resolve_acc
+    declare_remote_access
+    rd = MiGA::RemoteDataset
+    assert_equal('GCA_000175575.2', rd.ncbi_asm_resolve_acc('GCA_000175575'))
+    assert_equal('GCF_000175575.2', rd.ncbi_asm_resolve_acc('GCF_000175575'))
+    assert_raise(MiGA::RemoteDataMissingError) do
+      rd.ncbi_asm_resolve_acc('GCA_999999999')
+    end
+  end
+
+  def test_ncbi_asm_unversioned
+    declare_remote_access
+    rd = MiGA::RemoteDataset.new('GCA_000175575', :assembly, :ncbi)
+    ds = rd.save_to(project, 'unversioned')
+    assert_equal('GCA_000175575.2', ds.metadata[:ncbi_asm])
+    fna = ds.result(:assembly).file_path(:largecontigs)
+    assert_path_exist(fna)
+    assert_operator(File.size(fna), :>, 100_000)
+  end
+
+  # Payload returned by NCBI elink for IDs not recognized in +dbfrom+, which
+  # includes raw newlines within strings (and is therefore invalid JSON)
+  ELINK_NOT_FOUND =
+    '{"header":{"type":"elink","version":"0.3"},"linksets":[{' \
+    '"dbfrom":"nuccore","ids":[],"linksetdbs":[{"dbto":"biosample",' \
+    '"linkname":"nuccore_biosample","ERROR":"NCBI C++ Exception:' + "\n" +
+    '    Error: UNK_MODULE(CException::eInvalid) \"UNK_FILE\", line ' \
+    '18446744073709551615: UNK_FUNC --- ' + "\n" +
+    '"}],"ERROR":"BLOB ID IS NOT IMPLEMENTED"}]}'
+
+  def test_ncbi_map_offline
+    responses = {
+      # ID not recognized in nuccore
+      'GCA_039803745.1' => ELINK_NOT_FOUND,
+      # ID recognized, but the link failed (possibly transient)
+      'M30502.1' => ELINK_NOT_FOUND.sub('"ids":[]', '"ids":["1332355"]'),
+      # Unparseable response
+      'CP005986.1' => '<html>Service unavailable</html>',
+      # Normal responses, with and without links
+      'CP005986.2' =>
+        '{"header":{"type":"elink","version":"0.3"},"linksets":[{' \
+        '"dbfrom":"nuccore","ids":["640840007"],"linksetdbs":[{' \
+        '"dbto":"biosample","linkname":"nuccore_biosample",' \
+        '"links":["2469802"]}]}]}',
+      'M30502.2' =>
+        '{"header":{"type":"elink","version":"0.3"},"linksets":[{' \
+        '"dbfrom":"nuccore","ids":["1332355"]}]}'
+    }
+    calls = []
+    sleeps = 0
+    with_stubbed_class_method(:sleep, ->(*_args) { sleeps += 1 }) do
+      with_stubbed_download(lambda do |universe, db, ids, *_rest|
+        assert_equal(:ncbi_map, universe)
+        assert_equal(:nuccore, db)
+        calls << ids
+        responses[ids]
+      end) do
+        rd = MiGA::RemoteDataset
+
+        # Not found: no retries
+        err = assert_raise(MiGA::RemoteDataMissingError) do
+          rd.ncbi_map('GCA_039803745.1', :nuccore, :biosample)
+        end
+        assert_include(err.message, 'GCA_039803745.1')
+        assert_include(err.message, 'BLOB ID IS NOT IMPLEMENTED')
+        assert_equal(1, calls.size)
+        assert_equal(0, sleeps)
+
+        # Other errors: retry once and fail with a generic RemoteDataError
+        %w[M30502.1 CP005986.1].each do |id|
+          calls.clear
+          sleeps = 0
+          err = assert_raise(MiGA::RemoteDataError) do
+            rd.ncbi_map(id, :nuccore, :biosample)
+          end
+          assert_not_instance_of(MiGA::RemoteDataMissingError, err)
+          assert_include(err.message, id)
+          assert_equal([id, id], calls)
+          assert_equal(1, sleeps)
+        end
+
+        # Normal responses
+        sleeps = 0
+        assert_equal('2469802', rd.ncbi_map('CP005986.2', :nuccore, :biosample))
+        assert_nil(rd.ncbi_map('M30502.2', :nuccore, :biosample))
+        assert_equal(0, sleeps)
+      end
+    end
+  end
+
+  def test_type_status_nuccore_not_found_offline
+    rd = MiGA::RemoteDataset.new('GCA_039803745.1', :nuccore, :ncbi)
+    with_stubbed_download(->(*_args) { ELINK_NOT_FOUND }) do
+      md = { ncbi_nuccore: 'GCA_039803745.1' }
+      assert_equal(md, rd.get_type_status(md))
+    end
+  end
+
+  def test_ncbi_gb_get_efetch_error_offline
+    responses = {
+      'GCA_039803745.1' =>
+        "Error: F a i l e d  t o  u n d e r s t a n d  i d :  " \
+        "G C A _ 0 3 9 8 0 3 7 4 5 . 1 \n\n\n",
+      'M30502.1' => "Error: Something else went wrong\n"
+    }
+    with_stubbed_class_method(:download_rest, ->(opts) {
+      responses[opts[:ids].first]
+    }) do
+      rd = MiGA::RemoteDataset
+      err = assert_raise(MiGA::RemoteDataMissingError) do
+        rd.ncbi_gb_get(ids: ['GCA_039803745.1'], file: tmpfile('a.fna'))
+      end
+      assert_equal(
+        'NCBI nuccore entry not found: GCA_039803745.1 ' \
+        '(efetch: Failed to understand id: GCA_039803745.1)',
+        err.message
+      )
+
+      err = assert_raise(MiGA::RemoteDataError) do
+        rd.ncbi_gb_get(ids: ['M30502.1'], file: tmpfile('b.fna'))
+      end
+      assert_not_instance_of(MiGA::RemoteDataMissingError, err)
+      assert_include(err.message, 'Something else went wrong')
+    end
+  end
+
+  def test_ncbi_map_not_found
+    declare_remote_access
+    assert_raise(MiGA::RemoteDataMissingError) do
+      MiGA::RemoteDataset.ncbi_map('GCA_039803745.1', :nuccore, :biosample)
+    end
+  end
+
+  def test_nuccore_not_found
+    declare_remote_access
+    rd = MiGA::RemoteDataset.new('GCA_039803745.1', :nuccore, :ncbi)
+    err = assert_raise(MiGA::RemoteDataMissingError) do
+      rd.save_to(project, 'wrong_db')
+    end
+    assert_include(err.message, 'GCA_039803745.1')
+    assert_nil(project.dataset('wrong_db'))
+  end
+
   # This test is too expensive (too much time to run it!)
   # def test_net_timeout
   #   declare_remote_access
@@ -222,4 +487,35 @@ class RemoteDatasetTest < Test::Unit::TestCase
   #   rd = MiGA::RemoteDataset.new(bad, :assembly, :web)
   #   assert_raise(Net::ReadTimeout) { rd.save_to(project, "bad") }
   # end
+
+  private
+
+  ##
+  # Temporarily replace MiGA::RemoteDataset.download with +fun+ while running
+  # the given block
+  def with_stubbed_download(fun, &blk)
+    with_stubbed_class_method(:download, fun, &blk)
+  end
+
+  ##
+  # Temporarily replace the class method +name+ of MiGA::RemoteDataset with
+  # +fun+ while running the given block. Methods inherited by the class (like
+  # +sleep+) can also be stubbed
+  def with_stubbed_class_method(name, fun)
+    klass = MiGA::RemoteDataset.singleton_class
+    orig = :"__orig_#{name}"
+    own =
+      klass.method_defined?(name, false) ||
+      klass.private_method_defined?(name, false)
+    klass.send(:alias_method, orig, name) if own
+    klass.send(:define_method, name) { |*args| fun.call(*args) }
+    yield
+  ensure
+    if own
+      klass.send(:alias_method, name, orig)
+      klass.send(:remove_method, orig)
+    else
+      klass.send(:remove_method, name)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: miga-base
 version: !ruby/object:Gem::Version
-  version: 1.4.3.1
+  version: 1.4.4.0
 platform: ruby
 authors:
 - Luis M. Rodriguez-R
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-07 00:00:00.000000000 Z
+date: 2026-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: daemons