miga-base 0.7.4.0 → 0.7.5.0

data/test/metadata_test.rb

@@ -2,19 +2,11 @@ require 'test_helper'
 require 'miga/metadata'
 
 class MetadataTest < Test::Unit::TestCase
-
-  def setup
-    $tmp = Dir.mktmpdir
-    $jruby_tests = !ENV['JRUBY_TESTS'].nil?
-  end
-
-  def teardown
-    FileUtils.rm_rf $tmp
-  end
+  include TestHelper
 
   def test_save
-    omit_if($jruby_tests, 'JRuby doesn\'t implement fork.')
-    md1 = MiGA::Metadata.new(File.expand_path('md_save.json', $tmp))
+    declare_forks
+    md1 = MiGA::Metadata.new(tmpfile('md_save.json'))
     FileUtils.touch(md1.lock_file)
     fork do
       sleep(1)
@@ -28,9 +20,10 @@ class MetadataTest < Test::Unit::TestCase
   end
 
   def test_load
-    md1 = MiGA::Metadata.new(File.expand_path('md_load.json', $tmp), {t: 1})
+    md1 = MiGA::Metadata.new(tmpfile('md_load.json'), { t: 1 })
     assert_equal(1, md1[:t])
-    omit_if($jruby_tests, 'JRuby doesn\'t implement fork.')
+
+    declare_forks
     FileUtils.touch(md1.lock_file)
     fork do
       sleep(1)
@@ -44,5 +37,4 @@ class MetadataTest < Test::Unit::TestCase
     assert_path_not_exist(md1.lock_file)
     assert_ge(t2 - t1, 1.0)
   end
-
 end

data/test/project_test.rb

@@ -2,17 +2,10 @@ require 'test_helper'
 require 'miga/project'
 
 class ProjectTest < Test::Unit::TestCase
-  def setup
-    $tmp = Dir.mktmpdir
-    ENV['MIGA_HOME'] = $tmp
-    FileUtils.touch(File.expand_path('.miga_rc', ENV['MIGA_HOME']))
-    FileUtils.touch(File.expand_path('.miga_daemon.json', ENV['MIGA_HOME']))
-    $p1 = MiGA::Project.new(File.expand_path('project1', $tmp))
-  end
+  include TestHelper
 
-  def teardown
-    FileUtils.rm_rf $tmp
-    ENV['MIGA_HOME'] = nil
+  def setup
+    initialize_miga_home
   end
 
   def create_result_files(project, res, exts)
@@ -22,28 +15,26 @@ class ProjectTest < Test::Unit::TestCase
         project.add_result(res),
         "Premature registration of result #{res} at extension #{x}"
       )
-      FileUtils.touch(File.join(project.path, "data/#{d}/miga-project#{x}"))
+      FileUtils.touch(File.join(project.path, 'data', d, "miga-project#{x}"))
     end
   end
 
   def test_class_load
-    assert_nil(MiGA::Project.load($tmp + '/O_o'))
-    assert_equal(MiGA::Project, MiGA::Project.load($p1.path).class)
+    assert_nil(MiGA::Project.load(tmpfile('O_o')))
+    assert_instance_of(MiGA::Project, MiGA::Project.load(project.path))
   end
 
   def test_create
-    assert_equal("#{$tmp}/create", MiGA::Project.new("#{$tmp}/create").path)
-    assert_path_exist("#{$tmp}/create")
+    assert_equal(tmpfile('create'), project('create').path)
+    assert_path_exist(tmpfile('create'))
     assert_raise do
-      ENV['MIGA_HOME'] = $tmp + '/chez-moi'
-      MiGA::Project.new($tmp + '/cuckoo')
+      ENV['MIGA_HOME'] = tmpfile('chez-moi')
+      project('cuckoo')
     end
-  ensure
-    ENV['MIGA_HOME'] = $tmp
   end
 
   def test_load
-    p = MiGA::Project.new($tmp + '/load')
+    p = project('load')
     assert_equal(MiGA::Project, p.class)
     File.unlink p.metadata.path
     assert_raise do
@@ -52,8 +43,8 @@ class ProjectTest < Test::Unit::TestCase
   end
 
   def test_datasets
-    p = $p1
-    d = p.add_dataset('d1')
+    p = project
+    d = dataset(0, 'd1')
     assert_equal(MiGA::Dataset, d.class)
     assert_equal([d], p.datasets)
     assert_equal(['d1'], p.dataset_names)
@@ -65,55 +56,58 @@ class ProjectTest < Test::Unit::TestCase
   end
 
   def test_import_dataset
-    p1 = $p1
+    p1 = project
     d = p1.add_dataset('d1')
     File.open(
-      "#{p1.path}/data/01.raw_reads/#{d.name}.1.fastq", 'w'
+      File.join(p1.path, 'data', '01.raw_reads', "#{d.name}.1.fastq"), 'w'
     ) { |f| f.puts ':-)' }
     File.open(
-      "#{p1.path}/data/01.raw_reads/#{d.name}.done", 'w'
+      File.join(p1.path, 'data', '01.raw_reads', "#{d.name}.done"), 'w'
     ) { |f| f.puts ':-)' }
     d.next_preprocessing(true)
-    p2 = MiGA::Project.new(File.expand_path('import_dataset', $tmp))
+    p2 = project('import_dataset')
     assert_empty(p2.datasets)
     assert_nil(p2.dataset('d1'))
     p2.import_dataset(d)
     assert_equal(1, p2.datasets.size)
     assert_equal(MiGA::Dataset, p2.dataset('d1').class)
     assert_equal(1, p2.dataset('d1').results.size)
-    assert_path_exist(File.join(p2.path, "data/01.raw_reads/#{d.name}.1.fastq"))
-    assert_path_exist(File.join(p2.path, "metadata/#{d.name}.json"))
+    assert_path_exist(
+      File.join(p2.path, 'data', '01.raw_reads', "#{d.name}.1.fastq")
+    )
+    assert_path_exist(File.join(p2.path, 'metadata', "#{d.name}.json"))
   end
 
   def test_add_result
-    p1 = $p1
+    p1 = project
     assert_nil(p1.add_result(:doom))
     %w[.Rdata .log .txt .done].each do |x|
       assert_nil(p1.add_result(:haai_distances))
       FileUtils.touch(
-        File.join(p1.path, "data/09.distances/01.haai/miga-project#{x}")
+        File.join(
+          p1.path, 'data', '09.distances', '01.haai', "miga-project#{x}"
+        )
       )
     end
     assert_equal(MiGA::Result, p1.add_result(:haai_distances).class)
   end
 
   def test_result
-    p1 = $p1
+    p1 = project
     assert_nil(p1.result(:n00b))
     assert_nil(p1.result(:project_stats))
-    File.open(
-      File.expand_path('data/90.stats/miga-project.json', p1.path), 'w'
-    ) { |fh| fh.puts '{}' }
+    json = File.join(p1.path, 'data', '90.stats', 'miga-project.json')
+    File.open(json, 'w') { |fh| fh.puts '{}' }
     assert_not_nil(p1.result(:project_stats))
     assert_equal(1, p1.results.size)
   end
 
   def test_preprocessing
-    p1 = $p1
+    p1 = project
     assert_predicate(p1, :done_preprocessing?)
     d1 = p1.add_dataset('BAH')
     assert_not_predicate(p1, :done_preprocessing?)
-    FileUtils.touch(File.expand_path("data/90.stats/#{d1.name}.done", p1.path))
+    FileUtils.touch(File.join(p1.path, 'data', '90.stats', "#{d1.name}.done"))
     assert_predicate(p1, :done_preprocessing?)
     assert_nil(p1.next_inclade)
     p1.metadata[:type] = :clade
@@ -126,7 +120,7 @@ class ProjectTest < Test::Unit::TestCase
       aai_distances: %w[.Rdata .log .txt],
       ani_distances: %w[.Rdata .log .txt],
       clade_finding: %w[.pdf .classif .medoids
-        .class.tsv .class.nwk .proposed-clades],
+                        .class.tsv .class.nwk .proposed-clades],
       subclades: %w[.pdf .classif .medoids .class.tsv .class.nwk],
       ogs: %w[.ogs .stats]
     }
@@ -140,7 +134,7 @@ class ProjectTest < Test::Unit::TestCase
   end
 
   def test_empty_results
-    p1 = $p1
+    p1 = project
     p1.metadata[:type] = :clade
     %i[clade_finding subclades ogs].each do |r|
       assert_nil(p1.add_result(r), "Unexpected result exists: #{r}")
@@ -150,7 +144,7 @@ class ProjectTest < Test::Unit::TestCase
   end
 
   def test_force_result
-    p1 = $p1
+    p1 = project
     create_result_files(p1, :ogs, %w[.empty])
     date1 = p1.add_result(:ogs)[:created]
     sleep(1)

data/test/remote_dataset_test.rb

@@ -3,19 +3,10 @@ require 'miga/project'
 require 'miga/remote_dataset'
 
 class RemoteDatasetTest < Test::Unit::TestCase
+  include TestHelper
 
   def setup
-    $tmp = Dir.mktmpdir
-    ENV['MIGA_HOME'] = $tmp
-    FileUtils.touch(File.expand_path('.miga_rc', ENV["MIGA_HOME"]))
-    FileUtils.touch(File.expand_path('.miga_daemon.json', ENV["MIGA_HOME"]))
-    $p1 = MiGA::Project.new(File.expand_path('project1', $tmp))
-    $remote_tests = !ENV['REMOTE_TESTS'].nil?
-  end
-
-  def teardown
-    FileUtils.rm_rf $tmp
-    ENV['MIGA_HOME'] = nil
+    initialize_miga_home
   end
 
   def test_class_universe
@@ -33,7 +24,8 @@ class RemoteDatasetTest < Test::Unit::TestCase
     { embl: :ebi, nuccore: :ncbi }.each do |db, universe|
       rd = MiGA::RemoteDataset.new(hiv2, db, universe)
       assert_equal([hiv2], rd.ids)
-      omit_if(!$remote_tests, 'Remote access is error-prone')
+
+      declare_remote_access
       tx = rd.get_ncbi_taxonomy
       msg = "Failed on #{universe}:#{db}"
       assert_equal(MiGA::Taxonomy, tx.class, msg)
@@ -57,8 +49,9 @@ class RemoteDatasetTest < Test::Unit::TestCase
     n = 'Cjac_L14'
     rd = MiGA::RemoteDataset.new(cjac, :assembly_gz, :web)
     assert_equal([cjac], rd.ids)
-    omit_if(!$remote_tests, 'Remote access is error-prone')
-    p = $p1
+
+    declare_remote_access
+    p = project
     assert_nil(p.dataset(n))
     rd.save_to(p, n)
     p.add_dataset(n)
@@ -67,7 +60,7 @@ class RemoteDatasetTest < Test::Unit::TestCase
   end
 
   def test_asm_acc2id
-    omit_if(!$remote_tests, 'Remote access is error-prone')
+    declare_remote_access
     assert_nil(MiGA::RemoteDataset.ncbi_asm_acc2id('NotAnAccession'))
     id = MiGA::RemoteDataset.ncbi_asm_acc2id('GCA_004684205.1')
     assert_equal('2514661', id)
@@ -75,9 +68,9 @@ class RemoteDatasetTest < Test::Unit::TestCase
   end
 
   def test_update_metadata
-    omit_if(!$remote_tests, 'Remote access is error-prone')
+    declare_remote_access
     hiv1 = 'GCF_000856385.1'
-    d1 = MiGA::Dataset.new($p1, 'd1')
+    d1 = MiGA::Dataset.new(project, 'd1')
     assert_nil(d1.metadata[:ncbi_assembly])
     rd = MiGA::RemoteDataset.new(hiv1, :assembly, :ncbi)
     rd.update_metadata(d1, passthrough: 123, metadata_only: true)
@@ -87,36 +80,35 @@ class RemoteDatasetTest < Test::Unit::TestCase
   end
 
   def test_type_status_asm
-    omit_if(!$remote_tests, 'Remote access is error-prone')
+    declare_remote_access
     rd = MiGA::RemoteDataset.new('GCF_000018105.1', :assembly, :ncbi)
     assert { rd.get_metadata[:is_type] }
   end
 
   def test_nontype_status_asm
-    omit_if(!$remote_tests, 'Remote access is error-prone')
+    declare_remote_access
     rd = MiGA::RemoteDataset.new('GCA_004684205.1', :assembly, :ncbi)
     assert { !rd.get_metadata[:is_type] }
   end
 
   def test_type_status_nuccore
-    omit_if(!$remote_tests, 'Remote access is error-prone')
+    declare_remote_access
     rd = MiGA::RemoteDataset.new('NC_019748.1', :nuccore, :ncbi)
     assert { rd.get_metadata[:is_type] }
   end
 
   def test_ref_type_status
-    omit_if(!$remote_tests, 'Remote access is error-prone')
+    declare_remote_access
     rd = MiGA::RemoteDataset.new('GCA_002849345', :assembly, :ncbi)
     assert { !rd.get_metadata[:is_type] }
     assert { rd.get_metadata[:is_ref_type] }
   end
 
   # This test is too expensive (too much time to run it!)
-  #def test_net_timeout
-  #  omit_if(!$remote_tests, "Remote access is error-prone")
-  #  bad = "ftp://example.com/miga"
-  #  rd = MiGA::RemoteDataset.new(bad, :assembly, :web)
-  #  assert_raise(Net::ReadTimeout) { rd.save_to($p1, "bad") }
-  #end
-
+  # def test_net_timeout
+  #   declare_remote_access
+  #   bad = "ftp://example.com/miga"
+  #   rd = MiGA::RemoteDataset.new(bad, :assembly, :web)
+  #   assert_raise(Net::ReadTimeout) { rd.save_to(project, "bad") }
+  # end
 end

data/test/result_stats_test.rb

@@ -3,23 +3,14 @@ require 'miga/project'
 require 'zlib'
 
 class ResultStatsTest < Test::Unit::TestCase
+  include TestHelper
 
   def setup
-    $tmp = Dir.mktmpdir
-    ENV['MIGA_HOME'] = $tmp
-    FileUtils.touch(File.expand_path('.miga_rc', ENV['MIGA_HOME']))
-    FileUtils.touch(File.expand_path('.miga_daemon.json', ENV['MIGA_HOME']))
-    $p = MiGA::Project.new(File.expand_path('project1', $tmp))
-    $d = $p.add_dataset('dataset1')
-  end
-
-  def teardown
-    FileUtils.rm_rf $tmp
-    ENV['MIGA_HOME'] = nil
+    initialize_miga_home
   end
 
   def file_path(dir, ext)
-    File.join($p.path, dir, "#{$d.name}#{ext}")
+    File.join(project.path, dir, "#{dataset.name}#{ext}")
   end
 
   def touch_done(dir)
@@ -29,9 +20,9 @@ class ResultStatsTest < Test::Unit::TestCase
   def test_single_raw_reads
     dir = 'data/01.raw_reads'
     fq = file_path(dir, '.1.fastq')
-    File.open(fq, 'w') { |fh| fh.puts '@1','ACTAC','+','####' }
+    File.open(fq, 'w') { |fh| fh.puts '@1', 'ACTAC', '+', '####' }
     touch_done(dir)
-    r = $d.add_result(:raw_reads)
+    r = dataset.add_result(:raw_reads)
     assert_equal({}, r[:stats])
     r.compute_stats
     assert_not_empty(r[:stats])
@@ -43,11 +34,11 @@ class ResultStatsTest < Test::Unit::TestCase
   def test_coupled_raw_reads
     dir = 'data/01.raw_reads'
     fq = file_path(dir, '.1.fastq')
-    File.open(fq, 'w') { |fh| fh.puts '@1','ACTAC','+','####' }
+    File.open(fq, 'w') { |fh| fh.puts '@1', 'ACTAC', '+', '####' }
     fq = file_path(dir, '.2.fastq')
-    File.open(fq, 'w') { |fh| fh.puts '@1','ACTAC','+','####' }
+    File.open(fq, 'w') { |fh| fh.puts '@1', 'ACTAC', '+', '####' }
     touch_done(dir)
-    r = $d.add_result(:raw_reads)
+    r = dataset.add_result(:raw_reads)
     r.compute_stats
     assert_not_empty(r[:stats])
     assert_nil(r[:stats][:reads])
@@ -59,7 +50,7 @@ class ResultStatsTest < Test::Unit::TestCase
     dir = 'data/02.trimmed_reads'
     FileUtils.touch(file_path(dir, '.1.clipped.fastq'))
     touch_done(dir)
-    r = $d.add_result(:trimmed_reads)
+    r = dataset.add_result(:trimmed_reads)
     assert_equal({}, r[:stats])
     r.compute_stats
     assert_equal({}, r[:stats])
@@ -70,7 +61,7 @@ class ResultStatsTest < Test::Unit::TestCase
     Dir.mkdir(file_path(dir, '.solexaqa'))
     Dir.mkdir(file_path(dir, '.fastqc'))
     touch_done(dir)
-    r = $d.add_result(:read_quality)
+    r = dataset.add_result(:read_quality)
     assert_equal({}, r[:stats])
     r.compute_stats
     assert_equal({}, r[:stats])
@@ -79,9 +70,9 @@ class ResultStatsTest < Test::Unit::TestCase
   def test_trimmed_fasta
     dir = 'data/04.trimmed_fasta'
     fa = file_path(dir, '.CoupledReads.fa')
-    File.open(fa, 'w') { |fh| fh.puts '>1','ACTAC' }
+    File.open(fa, 'w') { |fh| fh.puts '>1', 'ACTAC' }
     touch_done(dir)
-    r = $d.add_result(:trimmed_fasta)
+    r = dataset.add_result(:trimmed_fasta)
     assert_equal({}, r[:stats])
     r.compute_stats
     assert_equal(1, r[:stats][:reads])
@@ -92,9 +83,9 @@ class ResultStatsTest < Test::Unit::TestCase
     # Prepare result
     dir = 'data/05.assembly'
     fa = file_path(dir, '.LargeContigs.fna')
-    File.open(fa, 'w') { |fh| fh.puts '>1','ACTAC' }
+    File.open(fa, 'w') { |fh| fh.puts '>1', 'ACTAC' }
     touch_done(dir)
-    r = $d.add_result(:assembly)
+    r = dataset.add_result(:assembly)
 
     # Test assertions
     assert_equal({}, r[:stats])
@@ -108,13 +99,13 @@ class ResultStatsTest < Test::Unit::TestCase
     # Prepare result
     dir = 'data/06.cds'
     fa = file_path(dir, '.faa')
-    File.open(fa, 'w') { |fh| fh.puts '>1','M' }
+    File.open(fa, 'w') { |fh| fh.puts '>1', 'M' }
     gff = file_path(dir, '.gff3.gz')
     Zlib::GzipWriter.open(gff) do |fh|
       fh.puts '# Model Data: a=b;transl_table=11;'
     end
     touch_done(dir)
-    r = $d.add_result(:cds)
+    r = dataset.add_result(:cds)
 
     # Test assertions
     assert_equal({}, r[:stats])
@@ -139,7 +130,7 @@ class ResultStatsTest < Test::Unit::TestCase
       fh.puts ' phylum Abc  0.0  **** '
     end
     touch_done(dir)
-    r = $d.add_result(:taxonomy)
+    r = dataset.add_result(:taxonomy)
 
     # Test assertions
     assert_nil(r[:stats][:closest_relative])
@@ -148,5 +139,4 @@ class ResultStatsTest < Test::Unit::TestCase
     assert_equal([100.0, '%'], r[:stats][:aai])
     assert_equal(0.0, r[:stats][:phylum_pvalue])
   end
-
 end

data/test/result_test.rb

@@ -2,62 +2,69 @@ require 'test_helper'
 require 'miga/project'
 
 class ResultTest < Test::Unit::TestCase
+  include TestHelper
 
   def setup
-    $tmp = Dir.mktmpdir
-    ENV['MIGA_HOME'] = $tmp
-    FileUtils.touch(File.expand_path('.miga_rc', ENV['MIGA_HOME']))
-    FileUtils.touch(File.expand_path('.miga_daemon.json', ENV['MIGA_HOME']))
-    $p1 = MiGA::Project.new(File.expand_path('project1', $tmp))
-    $d1 = $p1.add_dataset('dataset1')
+    initialize_miga_home
     FileUtils.touch(
-      File.join($p1.path, "data/02.trimmed_reads/#{$d1.name}.1.clipped.fastq"))
+      File.join(
+        project.path, 'data', '02.trimmed_reads',
+        "#{dataset.name}.1.clipped.fastq"
+      )
+    )
     FileUtils.touch(
-      File.join($p1.path, "data/02.trimmed_reads/#{$d1.name}.done"))
+      File.join(
+        project.path, 'data', '02.trimmed_reads', "#{dataset.name}.done"
+      )
+    )
     FileUtils.touch(
-      File.join($p1.path, 'data/10.clades/01.find/miga-project.empty'))
+      File.join(
+        project.path, 'data', '10.clades', '01.find', 'miga-project.empty'
+      )
+    )
     FileUtils.touch(
-      File.join($p1.path, 'data/10.clades/01.find/miga-project.done'))
-  end
-
-  def teardown
-    FileUtils.rm_rf $tmp
-    ENV['MIGA_HOME'] = nil
+      File.join(
+        project.path, 'data', '10.clades', '01.find', 'miga-project.done'
+      )
+    )
   end
 
   def test_add_result
-    r = $d1.add_result(:trimmed_reads)
-    assert_equal(MiGA::Result, r.class)
-    r = $d1.add_result(:asssembly)
+    r = dataset.add_result(:trimmed_reads)
+    assert_instance_of(MiGA::Result, r)
+    r = dataset.add_result(:asssembly)
     assert_nil(r)
-    r = $p1.add_result(:clade_finding)
-    assert_equal(MiGA::Result, r.class)
+    r = project.add_result(:clade_finding)
+    assert_instance_of(MiGA::Result, r)
   end
 
   def test_result_source
-    r = $d1.add_result(:trimmed_reads)
-    assert_equal($d1.name, r.source.name)
+    r = dataset.add_result(:trimmed_reads)
+    assert_equal(dataset.name, r.source.name)
     assert_equal(:trimmed_reads, r.key)
     assert_equal('data/02.trimmed_reads', r.relative_dir)
-    assert_equal('data/02.trimmed_reads/dataset1.json', r.relative_path)
-    assert_equal($p1.path, r.project.path)
-    assert_equal($p1.path, r.project_path)
-    r = $p1.add_result(:clade_finding)
-    assert_equal($p1.path, r.source.path)
+    assert_equal('data/02.trimmed_reads/dataset0.json', r.relative_path)
+    assert_equal(project.path, r.project.path)
+    assert_equal(project.path, r.project_path)
+    r = project.add_result(:clade_finding)
+    assert_equal(project.path, r.source.path)
   end
 
   def test_dates
-    r = $d1.add_result(:trimmed_reads)
+    r = dataset.add_result(:trimmed_reads)
     assert_nil(r.done_at)
     assert_nil(r.started_at)
-    tf = File.join($p1.path, "data/02.trimmed_reads/#{$d1.name}.done")
-    File.open(tf, 'w') { |fh| fh.puts Time.new(1,2,3,4,5) }
+    tf = File.join(
+      project.path, 'data', '02.trimmed_reads', "#{dataset.name}.done"
+    )
+    File.open(tf, 'w') { |fh| fh.puts Time.new(1, 2, 3, 4, 5) }
     assert_equal(Time, r.done_at.class)
     assert_nil(r.running_time)
-    tf = File.join($p1.path, "data/02.trimmed_reads/#{$d1.name}.start")
-    File.open(tf, 'w') { |fh| fh.puts Time.new(1,2,3,4,0) }
-    r = $d1.add_result(:trimmed_reads)
+    tf = File.join(
+      project.path, 'data', '02.trimmed_reads', "#{dataset.name}.start"
+    )
+    File.open(tf, 'w') { |fh| fh.puts Time.new(1, 2, 3, 4, 0) }
+    r = dataset.add_result(:trimmed_reads)
     assert_equal(5.0, r.running_time)
   end
-
 end