miga-base 0.6.4.2 → 0.7.0.0

data/test/dataset_test.rb

@@ -19,25 +19,25 @@ class DatasetTest < Test::Unit::TestCase
 
   def test_known_types
     assert_respond_to(MiGA::Dataset, :KNOWN_TYPES)
-    assert(MiGA::Dataset.KNOWN_TYPES.has_key?(:genome))
+    assert { MiGA::Dataset.KNOWN_TYPES.has_key?(:genome) }
   end
 
   def test_exist
     assert_respond_to(MiGA::Dataset, :exist?)
-    assert(MiGA::Dataset.exist?($p1, 'dataset1'))
-    assert(!MiGA::Dataset.exist?($p1, 'Nope'))
+    assert { MiGA::Dataset.exist?($p1, 'dataset1') }
+    assert { !MiGA::Dataset.exist?($p1, 'Nope') }
   end
 
   def test_info_fields
     assert_respond_to(MiGA::Dataset, :INFO_FIELDS)
-    assert(MiGA::Dataset.INFO_FIELDS.include?('name'))
+    assert { MiGA::Dataset.INFO_FIELDS.include?('name') }
   end
 
   def test_initialize
     assert_raise { MiGA::Dataset.new($p1, 'dataset-1') }
     assert_equal($p1, $d1.project)
     assert_equal('dataset1', $d1.name)
-    assert($d1.is_ref?)
+    assert_predicate($d1, :is_ref?)
     assert_equal(MiGA::Metadata, $d1.metadata.class)
   end
 
@@ -45,21 +45,21 @@ class DatasetTest < Test::Unit::TestCase
     d2 = $p1.add_dataset('ds_save')
     assert_respond_to(d2, :save)
     d2.save
-    assert(!d2.is_multi?)
-    assert(!d2.is_nonmulti?)
+    assert_not_predicate(d2, :is_multi?)
+    assert_not_predicate(d2, :is_nonmulti?)
     assert_nil(d2.metadata[:type])
     d2.metadata[:type] = :metagenome
     d2.save
     assert_equal(:metagenome, d2.metadata[:type])
-    assert(d2.is_multi?)
-    assert(!d2.is_nonmulti?)
+    assert_predicate(d2, :is_multi?)
+    assert_not_predicate(d2, :is_nonmulti?)
   end
 
   def test_remove
     d2 = $p1.add_dataset('ds_remove')
-    assert(File.exist?(d2.metadata.path))
+    assert_path_exist(d2.metadata.path)
     d2.remove!
-    assert(! File.exist?(d2.metadata.path))
+    assert_path_not_exist(d2.metadata.path)
   end
 
   def test_info
@@ -82,7 +82,7 @@ class DatasetTest < Test::Unit::TestCase
     d2 = $p1.add_dataset('ds_preprocessing')
     assert_nil(d2.first_preprocessing)
     assert_nil(d2.next_preprocessing)
-    assert(! d2.done_preprocessing?)
+    assert_not_predicate(d2, :done_preprocessing?)
     FileUtils.touch(File.expand_path(
       "data/02.trimmed_reads/#{d2.name}.1.clipped.fastq", $p1.path
     ))
@@ -91,26 +91,26 @@ class DatasetTest < Test::Unit::TestCase
     ))
     assert_equal(:trimmed_reads, d2.first_preprocessing(true))
     assert_equal(:read_quality, d2.next_preprocessing(true))
-    assert(! d2.done_preprocessing?(true))
+    assert { !d2.done_preprocessing?(true) }
     # Ref and undeclared multi
-    assert(d2.ignore_task?(:mytaxa))
-    assert(d2.ignore_task?(:mytaxa_scan))
-    assert(d2.ignore_task?(:distances))
+    assert { d2.ignore_task?(:mytaxa) }
+    assert { d2.ignore_task?(:mytaxa_scan) }
+    assert { d2.ignore_task?(:distances) }
     # Ref and multi
     d2.metadata[:type] = :metagenome
-    assert(! d2.ignore_task?(:mytaxa))
-    assert(d2.ignore_task?(:mytaxa_scan))
-    assert(d2.ignore_task?(:distances))
+    assert { !d2.ignore_task?(:mytaxa) }
+    assert { d2.ignore_task?(:mytaxa_scan) }
+    assert { d2.ignore_task?(:distances) }
     # Ref and nonmulti
     d2.metadata[:type] = :genome
-    assert(d2.ignore_task?(:mytaxa))
-    assert(! d2.ignore_task?(:mytaxa_scan))
-    assert(! d2.ignore_task?(:distances))
+    assert { d2.ignore_task?(:mytaxa) }
+    assert { !d2.ignore_task?(:mytaxa_scan) }
+    assert { !d2.ignore_task?(:distances) }
     # Qry and nonmulti
     d2.metadata[:ref] = false
-    assert(d2.ignore_task?(:mytaxa))
-    assert(d2.ignore_task?(:mytaxa_scan))
-    assert(! d2.ignore_task?(:distances))
+    assert { d2.ignore_task?(:mytaxa) }
+    assert { d2.ignore_task?(:mytaxa_scan) }
+    assert { !d2.ignore_task?(:distances) }
   end
 
   def test_profile_advance

data/test/hook_test.rb

@@ -78,18 +78,18 @@ class HookTest < Test::Unit::TestCase
   def test_dataset_run_cmd
     f = File.expand_path('hook_ds_cmd', $tmp)
     $d1.metadata[:on_remove] = [[:run_cmd, "echo {{dataset}} > '#{f}'"]]
-    assert(! File.exist?(f))
+    assert_path_not_exist(f)
     $d1.remove!
-    assert(File.exist? f)
+    assert_path_exist(f)
     assert_equal($d1.name, File.read(f).chomp)
   end
 
   def test_project_run_cmd
     f = File.expand_path('hook_pr_cmd', $tmp)
     $p1.add_hook(:on_save, :run_cmd, "echo {{project}} > '#{f}'")
-    assert(! File.exist?(f))
+    assert_path_not_exist(f)
     $p1.save
-    assert(File.exist? f)
+    assert_path_exist(f)
     assert_equal($p1.path, File.read(f).chomp)
   end
 

data/test/json_test.rb

@@ -4,11 +4,11 @@ class JsonTest < Test::Unit::TestCase
 
   def test_parse
     assert_equal(
-      {a: 1, b: 2},
+      { a: 1, b: 2 },
       MiGA::Json.parse('{"a": 1, "b": 2}', contents: true)
     )
     assert_equal(
-      {'a' => 1, 'b' => 2},
+      { 'a' => 1, 'b' => 2 },
       MiGA::Json.parse('{"a": 1, "b": 2}', contents: true, symbolize: false)
     )
     assert_equal(1.0, MiGA::Json.parse('1.0', contents: true))

data/test/lair_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+require 'miga/lair'
+
+class LairTest < Test::Unit::TestCase
+
+  def setup
+    $jruby_tests = !ENV['JRUBY_TESTS'].nil?
+    $tmp = Dir.mktmpdir
+    ENV['MIGA_HOME'] = $tmp
+    FileUtils.touch(File.expand_path('.miga_rc', ENV['MIGA_HOME']))
+    daemon_json = File.expand_path('.miga_daemon.json', ENV['MIGA_HOME'])
+    File.open(daemon_json, 'w') do |fh|
+      fh.puts '{"maxjobs":1,"ppn":1,"latency":1,"varsep":" ",
+        "var":"{{key}}={{value}}","cmd":"echo {{task_name}} >/dev/null",
+        "alive":"echo 1 # {{pid}}","type":"bash","format_version":1}'
+    end
+    Dir.mkdir(File.join($tmp, 'sub'))
+    $p1 = MiGA::Project.new(File.join($tmp, 'project1'))
+    $p2 = MiGA::Project.new(File.join($tmp, 'project2'))
+    $p3 = MiGA::Project.new(File.join($tmp, 'sub/project3'))
+  end
+
+  def teardown
+    FileUtils.rm_rf $tmp
+    ENV['MIGA_HOME'] = nil
+  end
+  
+  def test_lair_init
+    path = $tmp
+    lair = MiGA::Lair.new(path, name: 'Alt-X')
+    assert_equal(MiGA::Lair, lair.class)
+    assert_equal(path, lair.path)
+    assert_equal(path, lair.daemon_home)
+    assert_equal('MiGA:Alt-X', lair.daemon_name)
+    assert_equal(lair.daemon_home, MiGA::Lair.daemon_home(lair.daemon_home))
+  end
+
+  def test_in_loop
+    omit_if($jruby_tests, 'JRuby doesn\'t implement fork.')
+    lair = MiGA::Lair.new($tmp, name: 'Oh')
+    omit_if($jruby_tests, 'JRuby doesn\'t implement fork.')
+    child = lair.start(['--shush'])
+    assert_not_nil(child)
+    assert_gt(child, 0, 'The daemon process should have non-zero PID')
+    sleep(2)
+    capture_stderr { lair.stop }
+    assert_raise(Errno::ESRCH) { Process.kill(0, child) }
+    assert_nil(lair.declare_alive_pid)
+    assert_path_exist(lair.output_file)
+    l = File.readlines(lair.output_file)
+    assert_match(/-{20}\n/, l[0])
+    assert_match(/MiGA:Oh launched\n/, l[1])
+  end
+
+  def test_first_loop
+    lair = MiGA::Lair.new($tmp, name: 'Ew')
+    out = capture_stderr { lair.daemon_first_loop }.string
+    assert_match(/-{20}/, out)
+  end
+
+  def test_loop
+    lair = MiGA::Lair.new($tmp, name: 'Ew', latency: 1, dry: true)
+    out = capture_stderr { assert { !lair.daemon_loop } }.string
+    assert_match(/Launching daemon: \S*project1/, out)
+    assert_match(/Launching daemon: \S*project2/, out)
+    assert_match(/Launching daemon: \S*sub\/project3/, out)
+  end
+
+  def test_daemon_launch
+    lair = MiGA::Lair.new(File.join($tmp, 'sub'), latency: 1)
+    p = MiGA::Project.load(File.join(lair.path, 'project3'))
+    d = MiGA::Daemon.new(p)
+    assert_not_predicate(d, :active?)
+    assert_path_exist(d.daemon_home)
+
+    omit_if($jruby_tests, 'JRuby doesn\'t implement fork.')
+    capture_stdout do
+      FileUtils.touch(d.output_file) # <- To prevent test racing
+      out = capture_stderr { lair.check_directories }.string
+      assert_match(/Launching daemon: \S+project3/, out)
+      assert_predicate(d, :active?)
+    end
+
+    out = capture_stderr { lair.terminate_daemons }.string
+    assert_match(/Probing MiGA::Daemon/, out)
+    assert_match(/Sending termination message/, out)
+    sleep(2)
+    assert_not_predicate(d, :active?)
+
+    out = capture_stderr { assert { lair.daemon_loop } }.string
+    assert_equal('', out)
+  end
+end

data/test/metadata_test.rb

@@ -23,8 +23,8 @@ class MetadataTest < Test::Unit::TestCase
     t1 = Time.new
     md1.save
     t2 = Time.new
-    assert(! File.exist?(md1.lock_file))
-    assert(t2-t1 >= 1.0)
+    assert_path_not_exist(md1.lock_file)
+    assert_ge(t2 - t1, 1.0)
   end
 
   def test_load
@@ -41,8 +41,8 @@ class MetadataTest < Test::Unit::TestCase
     md1.load
     t2 = Time.new
     assert_equal(2, md1[:t])
-    assert(! File.exist?(md1.lock_file))
-    assert(t2-t1 >= 1.0)
+    assert_path_not_exist(md1.lock_file)
+    assert_ge(t2 - t1, 1.0)
   end
 
 end

data/test/project_test.rb

@@ -33,7 +33,7 @@ class ProjectTest < Test::Unit::TestCase
 
   def test_create
     assert_equal("#{$tmp}/create", MiGA::Project.new("#{$tmp}/create").path)
-    assert(Dir.exist?("#{$tmp}/create"))
+    assert_path_exist("#{$tmp}/create")
     assert_raise do
       ENV['MIGA_HOME'] = $tmp + '/chez-moi'
       MiGA::Project.new($tmp + '/cuckoo')
@@ -67,25 +67,23 @@ class ProjectTest < Test::Unit::TestCase
 
   def test_import_dataset
     p1 = $p1
-    d1 = p1.add_dataset('d1')
+    d = p1.add_dataset('d1')
     File.open(
-      "#{p1.path}/data/01.raw_reads/#{d1.name}.1.fastq", 'w'
+      "#{p1.path}/data/01.raw_reads/#{d.name}.1.fastq", 'w'
     ) { |f| f.puts ':-)' }
     File.open(
-      "#{p1.path}/data/01.raw_reads/#{d1.name}.done", 'w'
+      "#{p1.path}/data/01.raw_reads/#{d.name}.done", 'w'
     ) { |f| f.puts ':-)' }
-    d1.next_preprocessing(true)
+    d.next_preprocessing(true)
     p2 = MiGA::Project.new(File.expand_path('import_dataset', $tmp))
-    assert(p2.datasets.empty?)
+    assert_empty(p2.datasets)
     assert_nil(p2.dataset('d1'))
-    p2.import_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(
-      File.exist?(File.join(p2.path, "data/01.raw_reads/#{d1.name}.1.fastq"))
-    )
-    assert(File.exist?(File.join(p2.path, "metadata/#{d1.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
@@ -113,11 +111,11 @@ class ProjectTest < Test::Unit::TestCase
 
   def test_preprocessing
     p1 = $p1
-    assert(p1.done_preprocessing?)
+    assert_predicate(p1, :done_preprocessing?)
     d1 = p1.add_dataset('BAH')
-    assert(!p1.done_preprocessing?)
+    assert_not_predicate(p1, :done_preprocessing?)
     FileUtils.touch(File.expand_path("data/90.stats/#{d1.name}.done", p1.path))
-    assert(p1.done_preprocessing?)
+    assert_predicate(p1, :done_preprocessing?)
     assert_nil(p1.next_inclade)
     p1.metadata[:type] = :clade
     assert_equal(:subclades, p1.next_inclade)

data/test/remote_dataset_test.rb

@@ -20,7 +20,7 @@ class RemoteDatasetTest < Test::Unit::TestCase
 
   def test_class_universe
     assert_respond_to(MiGA::RemoteDataset, :UNIVERSE)
-    assert(MiGA::RemoteDataset.UNIVERSE.keys.include? :ebi)
+    assert_include(MiGA::RemoteDataset.UNIVERSE.keys, :ebi)
   end
 
   def test_bad_remote_dataset
@@ -89,26 +89,26 @@ class RemoteDatasetTest < Test::Unit::TestCase
   def test_type_status_asm
     omit_if(!$remote_tests, 'Remote access is error-prone')
     rd = MiGA::RemoteDataset.new('GCF_000018105.1', :assembly, :ncbi)
-    assert(rd.get_metadata[:is_type])
+    assert { rd.get_metadata[:is_type] }
   end
 
   def test_nontype_status_asm
     omit_if(!$remote_tests, 'Remote access is error-prone')
     rd = MiGA::RemoteDataset.new('GCA_004684205.1', :assembly, :ncbi)
-    assert(!rd.get_metadata[:is_type])
+    assert { !rd.get_metadata[:is_type] }
   end
 
   def test_type_status_nuccore
     omit_if(!$remote_tests, 'Remote access is error-prone')
     rd = MiGA::RemoteDataset.new('NC_019748.1', :nuccore, :ncbi)
-    assert(rd.get_metadata[:is_type])
+    assert { rd.get_metadata[:is_type] }
   end
 
   def test_ref_type_status
     omit_if(!$remote_tests, 'Remote access is error-prone')
     rd = MiGA::RemoteDataset.new('GCA_002849345', :assembly, :ncbi)
-    assert(!rd.get_metadata[:is_type])
-    assert(rd.get_metadata[:is_ref_type])
+    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!)

data/test/result_stats_test.rb

@@ -33,7 +33,7 @@ class ResultStatsTest < Test::Unit::TestCase
     r = $d.add_result(:raw_reads)
     assert_equal({}, r[:stats])
     r.compute_stats
-    assert(!r[:stats].empty?)
+    assert_not_empty(r[:stats])
     assert_equal(Hash, r[:stats].class)
     assert_equal(1, r[:stats][:reads])
     assert_equal([40.0, '%'], r[:stats][:g_c_content])
@@ -48,7 +48,7 @@ class ResultStatsTest < Test::Unit::TestCase
     touch_done(dir)
     r = $d.add_result(:raw_reads)
     r.compute_stats
-    assert(!r[:stats].empty?)
+    assert_not_empty(r[:stats])
     assert_nil(r[:stats][:reads])
     assert_equal(1, r[:stats][:read_pairs])
     assert_equal([40.0, '%'], r[:stats][:reverse_g_c_content])

data/test/tax_dist_test.rb

@@ -4,11 +4,11 @@ require 'miga/tax_dist'
 class TaxDistTest < Test::Unit::TestCase
 
   def test_aai_path
-    assert(File.size? MiGA::TaxDist.aai_path(:intax))
-    assert(File.size? MiGA::TaxDist.aai_path(:novel))
-    assert(File.size? MiGA::TaxDist.aai_path(:intax, engine: :diamond))
-    assert(File.size? MiGA::TaxDist.aai_path(:novel, engine: :blast))
-    assert(File.size? MiGA::TaxDist.aai_path(:novel, engine: :'blast+'))
+    assert_path_exist(MiGA::TaxDist.aai_path(:intax))
+    assert_path_exist(MiGA::TaxDist.aai_path(:novel))
+    assert_path_exist(MiGA::TaxDist.aai_path(:intax, engine: :diamond))
+    assert_path_exist(MiGA::TaxDist.aai_path(:novel, engine: :blast))
+    assert_path_exist(MiGA::TaxDist.aai_path(:novel, engine: :'blast+'))
   end
 
   def test_aai_pvalues

data/test/tax_index_test.rb

@@ -17,12 +17,12 @@ class TaxIndexTest < Test::Unit::TestCase
     d = p.add_dataset('dataset1')
 
     ti = MiGA::TaxIndex.new
-    assert(ti.datasets.empty?)
+    assert_empty(ti.datasets)
     ti << d
-    assert(ti.datasets.empty?, 'Index should ignore datasets without tax.')
+    assert_empty(ti.datasets, 'index should ignore datasets without tax')
     d.metadata[:tax] = MiGA::Taxonomy.new('k:Fantasia g:Unicornia')
     ti << d
-    assert_equal(1, ti.datasets.size, 'Index should have one dataset.')
+    assert_equal(1, ti.datasets.size, 'index should have one dataset')
     assert_equal(1, ti.root.datasets_count)
   ensure
     FileUtils.rm_rf $tmp
@@ -31,9 +31,9 @@ class TaxIndexTest < Test::Unit::TestCase
 
   def test_to_json
     js = JSON.parse(MiGA::TaxIndex.new.to_json)
-    assert(js.keys.include? 'datasets')
+    assert_include(js.keys, 'datasets')
     assert_equal(2, js.keys.size)
-    assert(js['datasets'].empty?)
+    assert_empty(js['datasets'])
   end
 
   def test_to_tab

data/test/taxonomy_test.rb

@@ -5,7 +5,7 @@ class TaxonomyTest < Test::Unit::TestCase
 
   def test_ranks
     assert_respond_to(MiGA::Taxonomy, :KNOWN_RANKS)
-    assert(MiGA::Taxonomy.KNOWN_RANKS.include? :s)
+    assert_include(MiGA::Taxonomy.KNOWN_RANKS, :s)
     assert_nil(MiGA::Taxonomy.normalize_rank 'No Rank')
     assert_nil(MiGA::Taxonomy.normalize_rank 'Captain')
     assert_equal(:f, MiGA::Taxonomy.normalize_rank(:Family))
@@ -41,7 +41,7 @@ class TaxonomyTest < Test::Unit::TestCase
     tx << { genus: 'v3' }
     assert_equal('v3', tx[:g])
     tx << 's:v3_0'
-    assert(tx.in? MiGA::Taxonomy.new('species:v3_0'))
+    assert { tx.in? MiGA::Taxonomy.new('species:v3_0') }
     assert_raise(RuntimeError) { tx << 123 }
   end
 
@@ -89,7 +89,7 @@ class TaxonomyTest < Test::Unit::TestCase
     # Delete
     alt = tx.delete_alternative
     assert_equal(4, alt.size)
-    assert(tx.alternative.empty?)
+    assert_empty(tx.alternative)
   end
 
   def test_reset