miga-base 0.7.4.0 → 0.7.5.0

data/test/dataset_test.rb

@@ -2,19 +2,10 @@ require 'test_helper'
 require 'miga/project'
 
 class DatasetTest < 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')
-  end
-
-  def teardown
-    FileUtils.rm_rf $tmp
-    ENV['MIGA_HOME'] = nil
+    initialize_miga_home
   end
 
   def test_known_types
@@ -23,9 +14,10 @@ class DatasetTest < Test::Unit::TestCase
   end
 
   def test_exist
+    dataset
     assert_respond_to(MiGA::Dataset, :exist?)
-    assert { MiGA::Dataset.exist?($p1, 'dataset1') }
-    assert { !MiGA::Dataset.exist?($p1, 'Nope') }
+    assert { MiGA::Dataset.exist?(project, dataset.name) }
+    assert { !MiGA::Dataset.exist?(project, 'Nope') }
   end
 
   def test_info_fields
@@ -34,16 +26,16 @@ class DatasetTest < Test::Unit::TestCase
   end
 
   def test_initialize
-    assert_raise { MiGA::Dataset.new($p1, 'dataset-1') }
-    assert_equal($p1, $d1.project)
-    assert_equal('dataset1', $d1.name)
-    assert_predicate($d1, :is_ref?)
-    assert_equal(MiGA::Metadata, $d1.metadata.class)
-    assert_equal(:incomplete, $d1.status)
+    assert_raise { MiGA::Dataset.new(project, 'dataset-1') }
+    assert_equal(project, dataset.project)
+    assert_equal('dataset0', dataset.name)
+    assert_predicate(dataset, :is_ref?)
+    assert_equal(MiGA::Metadata, dataset.metadata.class)
+    assert_equal(:incomplete, dataset.status)
   end
 
   def test_save
-    d2 = $p1.add_dataset('ds_save')
+    d2 = project.add_dataset('ds_save')
     assert_respond_to(d2, :save)
     d2.save
     assert_not_predicate(d2, :is_multi?)
@@ -57,39 +49,43 @@ class DatasetTest < Test::Unit::TestCase
   end
 
   def test_remove
-    d2 = $p1.add_dataset('ds_remove')
+    d2 = project.add_dataset('ds_remove')
     assert_path_exist(d2.metadata.path)
     d2.remove!
     assert_path_not_exist(d2.metadata.path)
   end
 
   def test_info
-    assert_equal($d1.name, $d1.info.first)
+    assert_equal(dataset.name, dataset.info.first)
   end
 
   def test_add_result
-    d2 = $p1.add_dataset('ds_add_result')
+    d2 = project.add_dataset('ds_add_result')
     assert_nil(d2.add_result(:koop))
     assert_nil(d2.add_result(:raw_reads))
     FileUtils.touch(
-      File.expand_path("data/01.raw_reads/#{d2.name}.1.fastq",$p1.path))
+      File.join(project.path, 'data', '01.raw_reads', "#{d2.name}.1.fastq")
+    )
     assert_nil(d2.add_result(:raw_reads))
     FileUtils.touch(
-      File.expand_path("data/01.raw_reads/#{d2.name}.done",$p1.path))
+      File.join(project.path, 'data', '01.raw_reads', "#{d2.name}.done")
+    )
     assert_equal(MiGA::Result, d2.add_result(:raw_reads).class)
   end
 
   def test_preprocessing
-    d2 = $p1.add_dataset('ds_preprocessing')
+    d2 = project.add_dataset('ds_preprocessing')
     assert_nil(d2.first_preprocessing)
     assert_nil(d2.next_preprocessing)
     assert_not_predicate(d2, :done_preprocessing?)
-    FileUtils.touch(File.expand_path(
-      "data/02.trimmed_reads/#{d2.name}.1.clipped.fastq", $p1.path
-    ))
-    FileUtils.touch(File.expand_path(
-      "data/02.trimmed_reads/#{d2.name}.done", $p1.path
-    ))
+    FileUtils.touch(
+      File.join(
+        project.path, 'data', '02.trimmed_reads', "#{d2.name}.1.clipped.fastq"
+      )
+    )
+    FileUtils.touch(
+      File.join(project.path, 'data', '02.trimmed_reads', "#{d2.name}.done")
+    )
     assert_equal(:trimmed_reads, d2.first_preprocessing(true))
     assert_equal(:read_quality, d2.next_preprocessing(true))
     assert { !d2.done_preprocessing?(true) }
@@ -115,28 +111,31 @@ class DatasetTest < Test::Unit::TestCase
   end
 
   def test_profile_advance
-    d2 = $p1.add_dataset('ds_profile_advance')
+    d2 = project.add_dataset('ds_profile_advance')
     assert_equal(0, d2.profile_advance(true).first)
     assert_equal(0, d2.profile_advance(true).last)
     assert_equal(0, d2.profile_advance(true).inject(:+))
-    Dir.mkdir(File.expand_path(
-      "data/03.read_quality/#{d2.name}.solexaqa", $p1.path
-    ))
-    Dir.mkdir(File.expand_path(
-      "data/03.read_quality/#{d2.name}.fastqc", $p1.path
-    ))
-    FileUtils.touch(File.expand_path(
-      "data/03.read_quality/#{d2.name}.done", $p1.path
-    ))
-    assert_equal([0,0,1,2], d2.profile_advance(true)[0..3])
+    Dir.mkdir(
+      File.join(project.path, 'data', '03.read_quality', "#{d2.name}.solexaqa")
+    )
+    Dir.mkdir(
+      File.join(project.path, 'data', '03.read_quality', "#{d2.name}.fastqc")
+    )
+    FileUtils.touch(
+      File.join(project.path, 'data', '03.read_quality', "#{d2.name}.done")
+    )
+    assert_equal([0, 0, 1, 2], d2.profile_advance(true)[0..3])
     assert_equal(2, d2.profile_advance(true).last)
   end
 
   def test_add_result_other
-    d2 = $p1.add_dataset('ds_add_result_other')
-    Dir.mkdir(File.expand_path(
-      "data/07.annotation/01.function/01.essential/#{d2.name}.ess", $p1.path
-    ))
+    d2 = project.add_dataset('ds_add_result_other')
+    Dir.mkdir(
+      File.join(
+        project.path, 'data', '07.annotation', '01.function', '01.essential',
+        "#{d2.name}.ess"
+      )
+    )
     to_test = {
       trimmed_fasta: [
         "data/04.trimmed_fasta/#{d2.name}.SingleReads.fa",
@@ -152,28 +151,28 @@ class DatasetTest < Test::Unit::TestCase
         "data/06.cds/#{d2.name}.done"
       ],
       essential_genes: %w[ess.faa ess/log done]
-        .map do |x|
-          "data/07.annotation/01.function/01.essential/#{d2.name}.#{x}"
-        end,
+            .map do |x|
+                   "data/07.annotation/01.function/01.essential/#{d2.name}.#{x}"
+                 end,
       ssu: [
         "data/07.annotation/01.function/02.ssu/#{d2.name}.ssu.fa",
         "data/07.annotation/01.function/02.ssu/#{d2.name}.done"
       ],
       mytaxa_scan: %w[pdf wintax mytaxa reg done]
-        .map do |x|
-          "data/07.annotation/03.qa/02.mytaxa_scan/#{d2.name}.#{x}"
-        end,
+            .map do |x|
+                   "data/07.annotation/03.qa/02.mytaxa_scan/#{d2.name}.#{x}"
+                 end,
       distances: [
         "data/09.distances/01.haai/#{d2.name}.db",
         "data/09.distances/#{d2.name}.done"
       ]
     }
-    to_test.each do |k,v|
+    to_test.each do |k, v|
       assert_nil(d2.add_result(k), "Result for #{k} should be nil.")
-      v.each { |i| FileUtils.touch(File.expand_path(i, $p1.path)) }
-      FileUtils.touch(File.expand_path(
-        "data/04.trimmed_fasta/#{d2.name}.done", $p1.path
-      ))
+      v.each { |i| FileUtils.touch(File.expand_path(i, project.path)) }
+      FileUtils.touch(
+        File.join(project.path, 'data', '04.trimmed_fasta', "#{d2.name}.done")
+      )
       assert_equal(
         MiGA::Result,
         d2.add_result(k).class,
@@ -183,7 +182,7 @@ class DatasetTest < Test::Unit::TestCase
   end
 
   def test_activate
-    d = $d1
+    d = dataset
     assert_equal(:incomplete, d.status)
     assert_predicate(d, :active?)
     d.inactivate!

data/test/format_test.rb

@@ -1,17 +1,10 @@
 require 'test_helper'
 
 class FormatTest < Test::Unit::TestCase
-
-  def setup
-    $tmp = Dir.mktmpdir
-  end
-
-  def teardown
-    FileUtils.rm_rf $tmp
-  end
+  include TestHelper
 
   def helper_write_file(content)
-    f = File.join($tmp, 'f.fa')
+    f = tmpfile('f.fa')
     File.open(f, 'w') { |h| h.print content }
     f
   end
@@ -76,7 +69,7 @@ class FormatTest < Test::Unit::TestCase
     o = MiGA::MiGA.seqs_length(f, :fastq, n50: true)
     assert_equal(3, o[:med])
   end
-  
+
   def test_tabulate
     tab = MiGA::MiGA.tabulate(%w[a b], [%w[123 45], %w[678 90]])
     assert_equal('  a  b ', tab[0])
@@ -84,5 +77,4 @@ class FormatTest < Test::Unit::TestCase
     assert_equal('123  45', tab[2])
     assert_equal('678  90', tab[3])
   end
-
 end

data/test/hook_test.rb

@@ -2,35 +2,24 @@ require 'test_helper'
 require 'miga/project'
 
 class HookTest < 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')
-  end
-
-  def teardown
-    FileUtils.rm_rf $tmp
-    ENV['MIGA_HOME'] = nil
+    initialize_miga_home
   end
 
   def test_add_hook
-    assert_nil($d1.hooks[:on_save])
-    $d1.add_hook(:on_save, :run_lambda, Proc.new { $counter += 1 })
-    assert_equal(1, $d1.hooks[:on_save].size)
+    assert_nil(dataset.hooks[:on_save])
+    dataset.add_hook(:on_save, :run_lambda, Proc.new { $counter += 1 })
+    assert_equal(1, dataset.hooks[:on_save].size)
     $counter = 1
-    $d1.save
+    dataset.save
     assert_equal(2, $counter)
   end
 
   def test_missing_action
-    $d1.add_hook(:on_save, :this_is_not_an_action)
-    assert_raise do
-      $d1.save
-    end
+    dataset.add_hook(:on_save, :this_is_not_an_action)
+    assert_raise { dataset.save }
   end
 
   ##
@@ -47,76 +36,82 @@ class HookTest < Test::Unit::TestCase
   def test_dataset_result_hooks
     $res = :test
     $counter = 1
-    $d1.add_hook(:on_result_ready,
-      :run_lambda, Proc.new { |r| $res = r })
-    $d1.add_hook(:on_result_ready_trimmed_reads,
-      :run_lambda, Proc.new { $counter += 1 })
-    FileUtils.touch(File.expand_path(
-      "data/02.trimmed_reads/#{$d1.name}.1.clipped.fastq", $p1.path))
-    FileUtils.touch(File.expand_path(
-      "data/02.trimmed_reads/#{$d1.name}.done", $p1.path))
+    dataset.add_hook(:on_result_ready, :run_lambda, Proc.new { |r| $res = r })
+    dataset.add_hook(
+      :on_result_ready_trimmed_reads, :run_lambda, Proc.new { $counter += 1 }
+    )
+    FileUtils.touch(
+      File.join(
+        project.path, 'data', '02.trimmed_reads',
+        "#{dataset.name}.1.clipped.fastq"
+      )
+    )
+    FileUtils.touch(
+      File.join(
+        project.path, 'data', '02.trimmed_reads', "#{dataset.name}.done"
+      )
+    )
     assert_equal(:test, $res)
-    $d1.add_result(:trimmed_reads)
+    dataset.add_result(:trimmed_reads)
     assert_equal(:trimmed_reads, $res)
     assert_equal(2, $counter)
   end
 
   def test_dataset_clear_run_counts
-    $d1.metadata[:_try_something] = 1
-    $d1.metadata[:_step] = 'Boop'
-    $d1.metadata[:_not_a_counter] = 1
-    $d1.save
-    assert_equal(1, $d1.metadata[:_try_something])
-    assert_equal('Boop', $d1.metadata[:_step])
-    $d1.add_hook(:on_remove, :clear_run_counts)
-    $d1.remove!
-    assert_nil($d1.metadata[:_try_something])
-    assert_nil($d1.metadata[:_step])
-    assert_equal(1, $d1.metadata[:_not_a_counter])
+    dataset.metadata[:_try_something] = 1
+    dataset.metadata[:_step] = 'Boop'
+    dataset.metadata[:_not_a_counter] = 1
+    dataset.save
+    assert_equal(1, dataset.metadata[:_try_something])
+    assert_equal('Boop', dataset.metadata[:_step])
+    dataset.add_hook(:on_remove, :clear_run_counts)
+    dataset.remove!
+    assert_nil(dataset.metadata[:_try_something])
+    assert_nil(dataset.metadata[:_step])
+    assert_equal(1, dataset.metadata[:_not_a_counter])
   end
 
   def test_dataset_run_cmd
-    f = File.expand_path('hook_ds_cmd', $tmp)
-    $d1.metadata[:on_remove] = [[:run_cmd, "echo {{dataset}} > '#{f}'"]]
+    f = tmpfile('hook_ds_cmd')
+    dataset.metadata[:on_remove] = [[:run_cmd, "echo {{dataset}} > '#{f}'"]]
     assert_path_not_exist(f)
-    $d1.remove!
+    dataset.remove!
     assert_path_exist(f)
-    assert_equal($d1.name, File.read(f).chomp)
+    assert_equal(dataset.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}'")
+    f = tmpfile('hook_pr_cmd')
+    project.add_hook(:on_save, :run_cmd, "echo {{project}} > '#{f}'")
     assert_path_not_exist(f)
-    $p1.save
+    project.save
     assert_path_exist(f)
-    assert_equal($p1.path, File.read(f).chomp)
+    assert_equal(project.path, File.read(f).chomp)
   end
 
   def test_project_result_hooks
     $res = :test
     $counter = 1
-    $p1.add_hook(
+    project.add_hook(
       :on_result_ready,
       :run_lambda,
       Proc.new { |r| $res = r }
     )
-    $p1.add_hook(
+    project.add_hook(
       :on_result_ready_project_stats,
       :run_lambda,
       Proc.new { $counter += 1 }
     )
     %w[taxonomy.json metadata.db done].each do |ext|
-      FileUtils.touch(File.expand_path(
-        "data/90.stats/miga-project.#{ext}", $p1.path
-      ))
+      FileUtils.touch(
+        File.join(project.path, 'data', '90.stats', "miga-project.#{ext}")
+      )
     end
-    assert_equal(:project_stats, $p1.next_task(nil, false))
+    assert_equal(:project_stats, project.next_task(nil, false))
     assert_equal(:test, $res)
     assert_equal(1, $counter)
-    assert_equal(:haai_distances, $p1.next_task)
+    assert_equal(:haai_distances, project.next_task)
     assert_equal(:project_stats, $res)
     assert_equal(2, $counter)
   end
-
 end

data/test/json_test.rb

@@ -1,7 +1,6 @@
 require 'test_helper'
 
 class JsonTest < Test::Unit::TestCase
-
   def test_parse
     assert_equal(
       { a: 1, b: 2 },
@@ -18,27 +17,27 @@ class JsonTest < Test::Unit::TestCase
     tmp1 = Tempfile.new('test-parse-1.json')
     tmp1.puts '{"a": 123, "k": false, "t": null}'
     tmp1.close
-    assert_equal({a: 123, k: false, t: nil}, MiGA::Json.parse(tmp1.path))
+    assert_equal({ a: 123, k: false, t: nil }, MiGA::Json.parse(tmp1.path))
 
     tmp2 = Tempfile.new('test-parse-2.json')
     tmp2.puts '{"a": 456, "kb": false, "t": 10.0}'
     tmp2.close
-    assert_equal({a: 456, kb: false, t: 10.0}, MiGA::Json.parse(tmp2.path))
+    assert_equal({ a: 456, kb: false, t: 10.0 }, MiGA::Json.parse(tmp2.path))
 
     assert_equal(
-      {a: 123, k: false, kb: false, t: nil},
+      { a: 123, k: false, kb: false, t: nil },
       MiGA::Json.parse(tmp1.path, default: tmp2.path)
     )
     assert_equal(
-      {a: 456, k: false, kb: false, t: 10.0},
+      { a: 456, k: false, kb: false, t: 10.0 },
       MiGA::Json.parse(tmp2.path, default: tmp1.path)
     )
   end
 
   def test_generate
-    assert_equal("{\n  \"a\": 1,\n  \"b\": 2\n}",
-      MiGA::Json.generate({a: 1, b: 2})
+    assert_equal(
+      "{\n  \"a\": 1,\n  \"b\": 2\n}",
+      MiGA::Json.generate({ a: 1, b: 2 })
     )
   end
-
 end

data/test/lair_test.rb

@@ -2,31 +2,26 @@ require 'test_helper'
 require 'miga/lair'
 
 class LairTest < Test::Unit::TestCase
+  include TestHelper
 
   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
+    initialize_miga_home(
+      <<~DAEMON
+        { "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 }
+      DAEMON
+    )
 
-  def teardown
-    FileUtils.rm_rf $tmp
-    ENV['MIGA_HOME'] = nil
+    # Make sure projects already exist
+    Dir.mkdir(tmpfile('sub'))
+    project(1)
+    project(2)
+    project('sub/project3')
   end
-  
+
   def test_lair_init
-    path = $tmp
+    path = tmpdir
     lair = MiGA::Lair.new(path, name: 'Alt-X')
     assert_equal(MiGA::Lair, lair.class)
     assert_equal(path, lair.path)
@@ -36,9 +31,8 @@ class LairTest < Test::Unit::TestCase
   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.')
+    declare_forks
+    lair = MiGA::Lair.new(tmpdir, name: 'Oh')
     child = lair.start(['--shush'])
     assert_not_nil(child)
     assert_gt(child, 0, 'The daemon process should have non-zero PID')
@@ -53,13 +47,13 @@ class LairTest < Test::Unit::TestCase
   end
 
   def test_first_loop
-    lair = MiGA::Lair.new($tmp, name: 'Ew')
+    lair = MiGA::Lair.new(tmpdir, 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)
+    lair = MiGA::Lair.new(tmpdir, 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)
@@ -67,13 +61,13 @@ class LairTest < Test::Unit::TestCase
   end
 
   def test_daemon_launch
-    lair = MiGA::Lair.new(File.join($tmp, 'sub'), latency: 1)
+    lair = MiGA::Lair.new(tmpfile('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.')
+    declare_forks
     capture_stdout do
       FileUtils.touch(d.output_file) # <- To prevent test racing
       out = capture_stderr { lair.check_directories }.string
@@ -92,7 +86,7 @@ class LairTest < Test::Unit::TestCase
   end
 
   def test_each_project
-    lair = MiGA::Lair.new($tmp)
+    lair = MiGA::Lair.new(tmpdir)
     y = []
     lair.each_project { |p| y << p }
     assert_equal(3, y.size)