lazar 0.9.3 → 1.0.0

data/test/dataset.rb

@@ -1,9 +1,16 @@
-# TODO; check compound/data_entry sequences with missing and duplicated values
-
 require_relative "setup.rb"
 
 class DatasetTest < MiniTest::Test
 
+  # basics
+
+  def test_create_empty
+    d = Dataset.new
+    assert_equal Dataset, d.class
+    refute_nil d.id
+    assert_kind_of BSON::ObjectId, d.id
+  end
+
   def test_all
     d1 = Dataset.new 
     d1.save
@@ -12,145 +19,182 @@ class DatasetTest < MiniTest::Test
     d1.delete
   end
 
-  def test_create_without_features_smiles_and_inchi
-    ["smiles", "inchi"].each do |type|
-      d = Dataset.from_csv_file File.join(DATA_DIR,"batch_prediction_#{type}_small.csv")
-      assert_equal Dataset, d.class
-      refute_nil d.id
-      dataset = Dataset.find d.id
-      #p dataset.compounds
-      assert_equal 3, d.compounds.size.to_i
-      d.delete
+  # real datasets
+
+  def test_upload_hamster
+    d = Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.csv"
+    assert_equal Dataset, d.class
+    assert_equal 1, d.features.size
+    assert_equal 85, d.compounds.size
+    csv = CSV.read("#{DATA_DIR}/hamster_carcinogenicity.csv")
+    csv.shift
+    csv.each do |row|
+      c = Compound.from_smiles row.shift
+      assert_equal row, d.values(c,d.features.first)
     end
+    d.delete 
   end
 
-  def test_create_empty
-    d = Dataset.new
-    assert_equal Dataset, d.class
-    refute_nil d.id
-    assert_kind_of BSON::ObjectId, d.id
+  def test_upload_kazius
+    f = File.join DATA_DIR, "kazius.csv"
+    d = OpenTox::Dataset.from_csv_file f 
+    csv = CSV.read f
+    assert_equal csv.size-1, d.compounds.size
+    assert_equal csv.first.size-1, d.features.size
+    assert_empty d.warnings
+    #  493 COC1=C(C=C(C(=C1)Cl)OC)Cl,1
+    c = d.compounds[491]
+    assert_equal c.smiles, "COc1cc(Cl)c(cc1Cl)OC"
+    assert_equal ["1"], d.values(c,d.features.first)
+    d.delete
   end
 
-  def test_client_create
-    d = Dataset.new
-    assert_equal Dataset, d.class
-    d.name = "Create dataset test"
-
-    # features not set
-    # << operator was removed for efficiency reasons (CH)
-    #assert_raises BadRequestError do
-    #  d << [Compound.from_smiles("c1ccccc1NN"), 1,2]
-    #end
-
-    # add data entries
-    d.features = ["test1", "test2"].collect do |title|
-      f = Feature.new 
-      f.name = title
-      f.numeric = true
-      f.save
-      f
+  def test_upload_multicell
+    duplicates = [
+      "InChI=1S/C6HCl5O/c7-1-2(8)4(10)6(12)5(11)3(1)9/h12H",
+      "InChI=1S/C12H8Cl6O/c13-8-9(14)11(16)5-3-1-2(6-7(3)19-6)4(5)10(8,15)12(11,17)18/h2-7H,1H2",
+      "InChI=1S/C2HCl3/c3-1-2(4)5/h1H",
+      "InChI=1S/C4H5Cl/c1-3-4(2)5/h3H,1-2H2",
+      "InChI=1S/C4H7Cl/c1-4(2)3-5/h1,3H2,2H3",
+      "InChI=1S/C8H14O4/c1-5-4-8(11-6(2)9)12-7(3)10-5/h5,7-8H,4H2,1-3H3",
+      "InChI=1S/C19H30O5/c1-3-5-7-20-8-9-21-10-11-22-14-17-13-19-18(23-15-24-19)12-16(17)6-4-2/h12-13H,3-11,14-15H2,1-2H3",
+    ].collect{|inchi| Compound.from_inchi(inchi).smiles}
+    errors = ['O=P(H)(OC)OC', 'C=CCNN.HCl' ]
+    f = File.join DATA_DIR, "multi_cell_call.csv"
+    d = OpenTox::Dataset.from_csv_file f 
+    csv = CSV.read f
+    assert_equal true, d.features.first.nominal?
+    assert_equal 1056, d.compounds.size
+    assert_equal csv.first.size-1, d.features.size
+    errors.each do |smi|
+      refute_empty d.warnings.grep %r{#{Regexp.escape(smi)}}
+    end
+    duplicates.each do |smi|
+      refute_empty d.warnings.grep %r{#{Regexp.escape(smi)}}
     end
-
-    # wrong feature size
-    # << operator was removed for efficiency reasons (CH)
-    #assert_raises BadRequestError do
-    #  d << [Compound.from_smiles("c1ccccc1NN"), 1,2,3]
-    #end
-    
-    # manual low-level insertions without consistency checks for runtime efficiency
-    data_entries = []
-    d.compound_ids << Compound.from_smiles("c1ccccc1NN").id
-    data_entries << [1,2]
-    d.compound_ids << Compound.from_smiles("CC(C)N").id
-    data_entries << [4,5]
-    d.compound_ids << Compound.from_smiles("C1C(C)CCCC1").id
-    data_entries << [6,7]
-    d.data_entries = data_entries
-    assert_equal 3, d.compounds.size
-    assert_equal 2, d.features.size
-    assert_equal [[1,2],[4,5],[6,7]], d.data_entries
-    d.save
-    # check if dataset has been saved correctly
-    new_dataset = Dataset.find d.id
-    assert_equal 3, new_dataset.compounds.size
-    assert_equal 2, new_dataset.features.size
-    assert_equal [[1,2],[4,5],[6,7]], new_dataset.data_entries
     d.delete
-    assert_nil Dataset.find d.id
-    assert_nil Dataset.find new_dataset.id
   end
 
-  def test_dataset_accessors
-    d = Dataset.from_csv_file "#{DATA_DIR}/multicolumn.csv"
-    # create empty dataset
-    new_dataset = Dataset.find d.id
-    # get metadata
-    assert_match "multicolumn.csv",  new_dataset.source
-    assert_equal "multicolumn",  new_dataset.name
-    # get features
-    assert_equal 6, new_dataset.features.size
-    assert_equal 7, new_dataset.compounds.size
-    assert_equal ["1", nil, "false", nil, nil, 1.0], new_dataset.data_entries.last
+  def test_upload_isscan
+    f = File.join DATA_DIR, "ISSCAN-multi.csv"
+    d = OpenTox::Dataset.from_csv_file f 
+    csv = CSV.read f
+    assert_equal csv.size-1, d.compounds.size
+    assert_equal csv.first.size-1, d.features.size
     d.delete
   end
 
-  def test_create_from_file
-    d = Dataset.from_csv_file File.join(DATA_DIR,"EPAFHM.mini.csv")
+  def test_upload_epafhm
+    f = File.join DATA_DIR, "EPAFHM_log10.csv"
+    d = OpenTox::Dataset.from_csv_file f
     assert_equal Dataset, d.class
-    refute_nil d.warnings
-    assert_match "EPAFHM.mini.csv",  d.source
-    assert_equal "EPAFHM.mini.csv",  d.name
-    d.delete 
-    #assert_equal false, URI.accessible?(d.uri)
+    csv = CSV.read f
+    assert_equal csv.size-1, d.compounds.size
+    assert_equal csv.first.size-1, d.features.size
+    assert_match "EPAFHM_log10.csv",  d.source
+    assert_equal "EPAFHM_log10",  d.name
+    feature = d.features.first
+    assert_kind_of NumericFeature, feature
+    assert_equal -Math.log10(0.0113), d.values(d.compounds.first,feature).first
+    assert_equal -Math.log10(0.00323), d.values(d.compounds[4],feature).first
+    d2 = Dataset.find d.id
+    assert_equal -Math.log10(0.0113), d2.values(d2.compounds[0],feature).first
+    assert_equal -Math.log10(0.00323), d2.values(d2.compounds[4],feature).first
+    d.delete
   end
 
-  def test_create_from_file_with_wrong_smiles_compound_entries
-    d = Dataset.from_csv_file File.join(DATA_DIR,"wrong_dataset.csv")
-    refute_nil d.warnings
-    assert_match /2|3|4|5|6|7|8/, d.warnings.join
-    d.delete
+  # batch predictions
+
+  def test_create_without_features_smiles_and_inchi
+    ["smiles", "inchi"].each do |type|
+      d = Dataset.from_csv_file File.join(DATA_DIR,"batch_prediction_#{type}_small.csv"), true
+      assert_equal Dataset, d.class
+      refute_nil d.id
+      dataset = Dataset.find d.id
+      assert_equal 3, d.compounds.size
+      d.delete
+    end
   end
 
-  def test_multicolumn_csv
+  # dataset operations
+
+  def test_folds
+    dataset = Dataset.from_csv_file File.join(DATA_DIR,"loael.csv")
+    dataset.folds(10).each do |fold|
+      fold.each do |d|
+        assert_operator d.compounds.size, :>=, d.compounds.uniq.size
+      end
+      assert_operator fold[0].compounds.size, :>=, fold[1].compounds.size
+      assert_equal dataset.substances.size, fold.first.substances.size + fold.last.substances.size
+      assert_empty (fold.first.substances & fold.last.substances)
+    end
+  end
+
+  # serialisation
+
+  def test_to_csv
     d = Dataset.from_csv_file "#{DATA_DIR}/multicolumn.csv"
     refute_nil d.warnings
     assert d.warnings.grep(/Duplicate compound/)  
     assert d.warnings.grep(/3, 5/)  
     assert_equal 6, d.features.size
-    assert_equal 7, d.compounds.size
+    assert_equal 5, d.compounds.uniq.size
     assert_equal 5, d.compounds.collect{|c| c.inchi}.uniq.size
-    assert_equal [["1", "1", "true", "true", "test", 1.1], ["1", "2", "false", "7.5", "test", 0.24], ["1", "3", "true", "5", "test", 3578.239], ["0", "4", "false", "false", "test", -2.35], ["1", "2", "true", "4", "test_2", 1], ["1", "2", "false", "false", "test", -1.5], ["1", nil, "false", nil, nil, 1.0]], d.data_entries
-    assert_equal "c1ccc[nH]1,1,,false,,,1.0", d.to_csv.split("\n")[7]
     csv = CSV.parse(d.to_csv)
     original_csv = CSV.read("#{DATA_DIR}/multicolumn.csv")
     csv.shift
     original_csv.shift
-    csv.each_with_index do |row,i|
-      compound = Compound.from_smiles row.shift
-      original_compound = Compound.from_smiles original_csv[i].shift.strip
-      assert_equal original_compound.inchi, compound.inchi
-      row.each_with_index do |v,j|
+    original = {}
+    original_csv.each do |row|
+      c = Compound.from_smiles row.shift.strip
+      original[c.inchi] = row.collect{|v| v.strip}
+    end
+    serialized = {}
+    csv.each do |row|
+      c = Compound.from_smiles row.shift
+      serialized[c.inchi] = row
+    end
+    #puts serialized.to_yaml
+    original.each do |inchi,row|
+      row.each_with_index do |v,i|
         if v.numeric?
-          assert_equal original_csv[i][j].strip.to_f, row[j].to_f
+          assert_equal v.to_f, serialized[inchi][i].to_f
         else
-          assert_equal original_csv[i][j].strip, row[j].to_s
+          assert_equal v, serialized[inchi][i]
         end
       end
+
     end
     d.delete 
   end
 
-  def test_from_csv
-    d = Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.csv"
-    assert_equal Dataset, d.class
-    assert_equal 1, d.features.size
-    assert_equal 85, d.compounds.size
-    assert_equal 85, d.data_entries.size
-    csv = CSV.read("#{DATA_DIR}/hamster_carcinogenicity.csv")
-    csv.shift
-    assert_equal csv.collect{|r| r[1]}, d.data_entries.flatten
-    d.delete 
-    #assert_equal false, URI.accessible?(d.uri)
+  # special cases/details
+
+  def test_dataset_accessors
+    d = Dataset.from_csv_file "#{DATA_DIR}/multicolumn.csv"
+    # create empty dataset
+    new_dataset = Dataset.find d.id
+    # get metadata
+    assert_match "multicolumn.csv",  new_dataset.source
+    assert_equal "multicolumn",  new_dataset.name
+    # get features
+    assert_equal 6, new_dataset.features.size
+    assert_equal 5, new_dataset.compounds.uniq.size
+    c = new_dataset.compounds.last
+    f = new_dataset.features.first
+    assert_equal ["1"], new_dataset.values(c,f)
+    f = new_dataset.features.last.id.to_s
+    assert_equal [1.0], new_dataset.values(c,f)
+    f = new_dataset.features[2]
+    assert_equal ["false"], new_dataset.values(c,f)
+    d.delete
+  end
+
+  def test_create_from_file_with_wrong_smiles_compound_entries
+    d = Dataset.from_csv_file File.join(DATA_DIR,"wrong_dataset.csv")
+    refute_nil d.warnings
+    assert_match /2|3|4|5|6|7|8/, d.warnings.join
+    d.delete
   end
 
   def test_from_csv_classification
@@ -158,9 +202,9 @@ class DatasetTest < MiniTest::Test
       d = Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.mini.bool_#{mode}.csv"
       csv = CSV.read("#{DATA_DIR}/hamster_carcinogenicity.mini.bool_#{mode}.csv")
       csv.shift
-      entries = d.data_entries.flatten
-      csv.each_with_index do |r, i|
-        assert_equal r[1].to_s, entries[i]
+      csv.each do |row|
+        c = Compound.from_smiles row.shift
+        assert_equal row, d.values(c,d.features.first)
       end
       d.delete 
     end
@@ -169,7 +213,7 @@ class DatasetTest < MiniTest::Test
   def test_from_csv2
     File.open("#{DATA_DIR}/temp_test.csv", "w+") { |file| file.write("SMILES,Hamster\nCC=O,true\n ,true\nO=C(N),true") }
     dataset = Dataset.from_csv_file "#{DATA_DIR}/temp_test.csv"
-    assert_equal "Cannot parse SMILES compound '' at position 3, all entries are ignored.",  dataset.warnings.join
+    assert_equal "Cannot parse SMILES compound '' at line 3 of /home/ist/lazar/test/data/temp_test.csv, all entries are ignored.",  dataset.warnings.join
     File.delete "#{DATA_DIR}/temp_test.csv"
     dataset.features.each{|f| feature = Feature.find f.id; feature.delete}
     dataset.delete
@@ -187,32 +231,50 @@ class DatasetTest < MiniTest::Test
     datasets.each{|d| d.delete}
   end
 
-  def test_create_from_file
-    d = Dataset.from_csv_file File.join(DATA_DIR,"EPAFHM.mini.csv")
-    assert_equal Dataset, d.class
-    refute_nil d.warnings
-    assert_match /row 13/, d.warnings.join
-    assert_match "EPAFHM.mini.csv",  d.source
-    assert_equal 1, d.features.size
-    feature = d.features.first
-    assert_kind_of NumericBioAssay, feature
-    assert_equal 0.0113, d.data_entries[0][0]
-    assert_equal 0.00323, d.data_entries[5][0]
-    d2 = Dataset.find d.id
-    assert_equal 0.0113, d2.data_entries[0][0]
-    assert_equal 0.00323, d2.data_entries[5][0]
+  def test_simultanous_upload
+    threads = []
+    3.times do |t|
+      threads << Thread.new(t) do |up|
+        d = OpenTox::Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.csv"
+        assert_equal OpenTox::Dataset, d.class
+        assert_equal 1, d.features.size
+        assert_equal 85, d.compounds.size
+        csv = CSV.read("#{DATA_DIR}/hamster_carcinogenicity.csv")
+        csv.shift
+        csv.each do |row|
+          c = Compound.from_smiles(row.shift)
+          assert_equal row, d.values(c,d.features.first)
+        end
+        d.delete 
+      end
+    end
+    threads.each {|aThread| aThread.join}
   end
 
-  def test_folds
-    dataset = Dataset.from_csv_file File.join(DATA_DIR,"loael.csv")
-    dataset.folds(10).each do |fold|
-      fold.each do |d|
-        assert_equal d.data_entries.size, d.compound_ids.size
-        assert_operator d.compound_ids.size, :>=, d.compound_ids.uniq.size
-      end
-      assert_operator fold[0].compound_ids.uniq.size, :>=, fold[1].compound_ids.uniq.size
+  def test_upload_feature_dataset
+    skip
+    t = Time.now
+    f = File.join DATA_DIR, "rat_feature_dataset.csv"
+    d = Dataset.from_csv_file f
+    assert_equal 458, d.features.size
+    d.save
+    #p "Upload: #{Time.now-t}"
+    d2 = Dataset.find d.id
+    t = Time.now
+    assert_equal d.features.size, d2.features.size
+    csv = CSV.read f
+    csv.shift # remove header
+    assert_empty d2.warnings
+    assert_equal csv.size, d2.compounds.size 
+    assert_equal csv.first.size-1, d2.features.size
+    d2.compounds.each_with_index do |compound,i|
+      row = csv[i]
+      row.shift # remove compound
+      assert_equal row, d2.data_entries[i]
     end
-    #puts dataset.folds 10
+    #p "Dowload: #{Time.now-t}"
+    d2.delete
+    assert_nil Dataset.find d.id
   end
 
 end

data/test/descriptor.rb

@@ -4,15 +4,17 @@ class DescriptorTest < MiniTest::Test
 
   def test_list
     # check available descriptors
-    assert_equal 355,PhysChem.descriptors.size,"incorrect number of physchem descriptors"
     assert_equal 15,PhysChem.openbabel_descriptors.size,"incorrect number of Openbabel descriptors"
-    assert_equal 295,PhysChem.cdk_descriptors.size,"incorrect number of Cdk descriptors"
     assert_equal 45,PhysChem.joelib_descriptors.size,"incorrect number of Joelib descriptors"
+    assert_equal 286,PhysChem.cdk_descriptors.size,"incorrect number of Cdk descriptors"
+    assert_equal 346,PhysChem.descriptors.size,"incorrect number of physchem descriptors"
   end
 
   def test_smarts
     c = OpenTox::Compound.from_smiles "N=C=C1CCC(=F=FO)C1"
-    File.open("tmp.png","w+"){|f| f.puts c.png}
+    File.open("/tmp/tmp.png","w+"){|f| f.puts c.png}
+    assert_match /^PNG/,`file -b /tmp/tmp.png`
+    File.delete "/tmp/tmp.png"
     s = Smarts.find_or_create_by(:smarts => "F=F")
     result = c.smarts_match [s]
     assert_equal [1], result
@@ -26,43 +28,50 @@ class DescriptorTest < MiniTest::Test
 
   def test_compound_openbabel_single
     c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
-    result = c.physchem [PhysChem.find_or_create_by(:name => "Openbabel.logP")]
-    assert_equal 1.12518, result.first.last.round(5)
+    feature = PhysChem.find_or_create_by(:name => "Openbabel.logP")
+    result = c.calculate_properties([feature])
+    assert_equal 1.12518, result.first.round(5)
+    assert_equal 1.12518, c.properties[feature.id.to_s].round(5)
   end
 
   def test_compound_cdk_single
     c = OpenTox::Compound.from_smiles "c1ccccc1"
-    result = c.physchem [PhysChem.find_or_create_by(:name => "Cdk.AtomCount.nAtom")]
-    assert_equal 12, result.first.last
+    feature = PhysChem.find_or_create_by(:name => "Cdk.AtomCount.nAtom")
+    result = c.calculate_properties([feature])
+    assert_equal 12, result.first
     c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
-    result = c.physchem [PhysChem.find_or_create_by(:name => "Cdk.AtomCount.nAtom")]
-    assert_equal 17, result.first.last
+    feature = PhysChem.find_or_create_by(:name => "Cdk.AtomCount.nAtom")
+    result = c.calculate_properties([feature])
+    assert_equal 17, result.first
     c_types = {"Cdk.CarbonTypes.C1SP1"=>1, "Cdk.CarbonTypes.C2SP1"=>0, "Cdk.CarbonTypes.C1SP2"=>0, "Cdk.CarbonTypes.C2SP2"=>1, "Cdk.CarbonTypes.C3SP2"=>0, "Cdk.CarbonTypes.C1SP3"=>2, "Cdk.CarbonTypes.C2SP3"=>1, "Cdk.CarbonTypes.C3SP3"=>1, "Cdk.CarbonTypes.C4SP3"=>0}
     physchem_features = c_types.collect{|t,nr| PhysChem.find_or_create_by(:name => t)}
-    result = c.physchem physchem_features
-    assert_equal [1, 0, 0, 1, 0, 2, 1, 1, 0], result.values
+    result = c.calculate_properties physchem_features
+    assert_equal [1, 0, 0, 1, 0, 2, 1, 1, 0], result
   end
 
   def test_compound_joelib_single
     c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
-    result = c.physchem [PhysChem.find_or_create_by(:name => "Joelib.LogP")]
-    assert_equal 2.65908, result.first.last
+    result = c.calculate_properties [PhysChem.find_or_create_by(:name => "Joelib.LogP")]
+    assert_equal 2.65908, result.first
   end
 
   def test_compound_all
     c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
-    result = c.physchem PhysChem.descriptors
     amr = PhysChem.find_or_create_by(:name => "Cdk.ALOGP.AMR", :library => "Cdk")
     sbonds = PhysChem.find_by(:name => "Openbabel.sbonds")
-    assert_equal 30.8723, result[amr.id.to_s]
-    assert_equal 5, result[sbonds.id.to_s]
+    result = c.calculate_properties([amr,sbonds])
+    assert_equal 30.8723, result[0]
+    assert_equal 5, result[1]
   end
 
   def test_compound_descriptor_parameters
+    PhysChem.descriptors
     c = OpenTox::Compound.from_smiles "CC(=O)CC(C)C#N"
-    result = c.physchem [ "Openbabel.logP", "Cdk.AtomCount.nAtom", "Joelib.LogP" ].collect{|d| PhysChem.find_or_create_by(:name => d)}
+    result = c.calculate_properties [ "Openbabel.logP", "Cdk.AtomCount.nAtom", "Joelib.LogP" ].collect{|d| PhysChem.find_or_create_by(:name => d)}
     assert_equal 3, result.size
-    assert_equal [1.12518, 17.0, 2.65908], result.values.collect{|v| v.round 5}
+    assert_equal 1.12518, result[0].round(5)
+    assert_equal 17.0, result[1].round(5)
+    assert_equal 2.65908, result[2].round(5)
   end
 
 end

data/test/error.rb

@@ -8,8 +8,8 @@ class ErrorTest < MiniTest::Test
   end
 
   def test_error_methods
-    assert_raises OpenTox::ResourceNotFoundError do
-      resource_not_found_error "This is a test"
+    assert_raises OpenTox::NotFoundError do
+      not_found_error "This is a test"
     end
   end
 

data/test/experiment.rb

@@ -5,7 +5,7 @@ class ExperimentTest < MiniTest::Test
   def test_regression_experiment
     skip
     datasets = [
-      "EPAFHM.medi.csv",
+      "EPAFHM.medi_log10.csv",
       #"EPAFHM.csv",
       #"FDA_v3b_Maximum_Recommended_Daily_Dose_mmol.csv",
       "LOAEL_mmol_corrected_smiles.csv"
@@ -68,7 +68,7 @@ class ExperimentTest < MiniTest::Test
     skip
 #=begin
     datasets = [
-      "EPAFHM.medi.csv",
+      "EPAFHM.medi_log10.csv",
       #"LOAEL_mmol_corrected_smiles.csv"
     ]
     min_sims = [0.3,0.7]
@@ -118,7 +118,7 @@ class ExperimentTest < MiniTest::Test
   def test_mpd_fingerprints
     skip
     datasets = [
-      "EPAFHM.medi.csv",
+      "EPAFHM.medi_log10.csv",
     ]
     types = ["FP2","MP2D"]
     experiment = Experiment.create(
@@ -147,7 +147,7 @@ class ExperimentTest < MiniTest::Test
   def test_multiple_datasets
     skip
     datasets = [
-      "EPAFHM.medi.csv",
+      "EPAFHM.medi_log10.csv",
       "LOAEL_mmol_corrected_smiles.csv"
     ]
     min_sims = [0.3]

data/test/feature.rb

@@ -32,10 +32,9 @@ class FeatureTest < MiniTest::Test
   def test_duplicated_features
     metadata = {
       :name => "feature duplication test",
-      :nominal => true,
     }
-    feature = NumericBioAssay.find_or_create_by metadata
-    dup_feature = NumericBioAssay.find_or_create_by metadata
+    feature = NumericFeature.find_or_create_by metadata
+    dup_feature = NumericFeature.find_or_create_by metadata
     assert_kind_of Feature, feature
     assert !feature.id.nil?, "No Feature ID in #{feature.inspect}"
     assert !feature.id.nil?, "No Feature ID in #{dup_feature.inspect}"

data/test/gridfs.rb

@@ -0,0 +1,10 @@
+require_relative "setup.rb"
+
+class GridFSTest < MiniTest::Test
+
+  def test_gridfs
+    file = Mongo::Grid::File.new("TEST", :filename => "test.txt",:content_type => "text/plain")
+    id = $gridfs.insert_one file
+    refute_nil id
+  end
+end